home *** CD-ROM | disk | FTP | other *** search
/ Sampler of Digital Rock Core Information / Sampler of Digital Rock Core Information Open File Report 91-355.ISO / source / imvis.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-21  |  103.1 KB  |  4,701 lines
  1. /*
  2.     imvis.c
  3.  
  4.     imv1.bat = cl /AL imvis.c vimage3 graphlib
  5.  
  6.     last update 11/25/91
  7.  
  8.     by Russell A. Ambroziak, Ph. D.
  9.  
  10.     U. S. Geological Survey
  11.     Office of Energy and Marine Geology
  12.     National Center , STOP 915
  13.     Reston, VA 22092
  14.  
  15.     Tel:  703-648-6168
  16.     Fax:  703-648-5464
  17.  
  18. */
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <math.h>
  22. #include <sys\types.h>
  23. #include <sys\timeb.h>
  24. #include <direct.h>
  25. #include "font.h"
  26.  
  27. #define MAX_BUFF 32768
  28. #define MENU_I 10
  29. #define MENUXC 550
  30. #define MENU_C 5
  31. #define MENU_S 3
  32. #define NUM_IMAGE 15
  33. #define S_SIZE 40
  34. #define F_SIZE 20
  35. #define T_SIZE 15
  36. #define PAUSE printf("HIT ANY KEY TO CONTINUE.\n");getch()
  37. #define MAX_LL 6
  38. #define NUM_DP 100
  39. #define STR_LEN 100
  40. #define MAX_NUM 300
  41. #define S_SIZE 40
  42. #define NAME_SIZE 100
  43. #define NUM_TYPE 25
  44. #define NUM_SIZE 25
  45. #define R      6367.40
  46. #define PI        3.1415927
  47. #define BLACK     0
  48. #define D_GREY    1
  49. #define L_GREY    2
  50. #define WHITE     3
  51. #define BUFF      4
  52. #define L_BUFF    5
  53. #define BROWN     6
  54. #define RED       7
  55. #define ORANGE    8
  56. #define YELLOW    9
  57. #define GREEN    10
  58. #define D_GREEN  11
  59. #define VD_GREEN 12
  60. #define BLUE     13
  61. #define D_BLUE   14
  62. #define MAGENTA  15
  63.  
  64. char Group_Name[NUM_TYPE][30];
  65. struct line_name
  66. {
  67.     char filename[54];
  68.     float max_pix,min_pix;
  69.     int color;
  70. }MapFile[NUM_TYPE][NUM_SIZE];
  71. int Vector=0;
  72. int Ns[NUM_TYPE];
  73.  
  74. extern char GF_String[MAX_NUM][S_SIZE];
  75. int GF_Order[MAX_NUM];
  76. long Hist[256],Delay;
  77. float Fhist[3][256],Fsum[3],Ftot[3];
  78. struct file_id
  79. {
  80.     char name[S_SIZE];
  81.     long size;
  82.     unsigned date,time;
  83. };
  84. extern struct file_id GF_File[300];
  85. struct board
  86. {
  87.     int row,col,color;
  88. }B_Id;
  89. int FontSize=2;
  90. char *menu_s[MENU_S]=
  91. {
  92.     "display image",
  93.     "cycle images",
  94.     "exit set"
  95. };
  96. struct navigation
  97. {
  98.     int numlat,numlon,numx,numy;
  99.     double B_Lat[MAX_LL],B_Lon[MAX_LL];
  100.     double B_Y[MAX_LL],B_X[MAX_LL];
  101. }Nav;
  102. int NumPath=1;
  103. char Path[NUM_DP][STR_LEN];
  104. char String[100];
  105. int PathOn=0;
  106. int Num_Active_Image=1;
  107. char *LastFile;
  108. char *menu_l[NUM_IMAGE+1]=
  109. {
  110.      "\0                              ",
  111.      "\0                              ",
  112.      "\0                              ",
  113.      "\0                              ",
  114.      "\0                              ",
  115.      "\0                              ",
  116.      "\0                              ",
  117.      "\0                              ",
  118.      "\0                              ",
  119.      "\0                              ",
  120.      "\0                              ",
  121.      "\0                              ",
  122.      "\0                              ",
  123.      "\0                              ",
  124.      "\0                              ",
  125.      "\0                              "
  126. };
  127. char *menu_i[MENU_I]=
  128.     {"zoom",                        /*  0 */
  129.     "change color",            /*  1 */
  130.     "pixel info",                /*  2 */
  131.     "output Targa file",        /*  3 */
  132.     "histogram",                /*  4 */
  133.     "Shade",                        /*  5 */
  134.     "smooth",                    /*  6 */
  135.     "boundary plot",            /*  7 */
  136.     "rescale image",            /*  8 */
  137.     "exit image"                /*  9 */
  138. };
  139. char *menu_c[MENU_C]=
  140.     {"change +/-,789,123","stretch RGB","reset","save new table","exit color"};
  141. float Hue[256],Sat[256];
  142. int Max[256],Mid[256],Min[256];
  143. char VideoType='X';
  144. int OneImage=0;
  145. char OneImageName[100];
  146. int Black=0,White=191,Center=128,Num_Color=256;
  147. int D_Grey=46,L_Grey=191,M_Grey=128;
  148. int ScreenXs=640,ScreenYs=480;
  149. struct   Color
  150. {
  151.     unsigned char  r, g, b;
  152. };
  153. struct Color Vcolor[16]=
  154. {
  155.     {   0,  0,  0},
  156.     {  46, 46, 46},
  157.     { 128,128,128},
  158.     { 255,255,255},
  159.     { 105, 90, 75},
  160.     { 130,111, 93},
  161.     {  96, 28, 14},
  162.     { 255,  0,  0},
  163.     { 255,128,  0},
  164.     { 160,160,  0},
  165.     {   0,200,  0},
  166.     {   0,120,  0},
  167.     {   0, 72,  0},
  168.     {   0,  0,200},
  169.     {   0, 20, 60},
  170.     { 255,  0,255}
  171. };
  172. struct Color Blk={  0,  0,  0};
  173. struct Color D_G={ 46, 46, 46};
  174. struct Color M_G={127,127,127};
  175. struct Color L_G={191,191,191};
  176. struct Color Wht={255,255,255};
  177. unsigned char ActiveLut;
  178. struct image_header
  179. {
  180.     int row,col;
  181.     int sample;
  182.     int record_bytes,file_records;
  183.     int record_col_header;
  184.     int row_col_header;
  185.     long header_bytes;
  186.     int imbedded_header;
  187.     int sample_bits;
  188.     int data_max,data_min;
  189.     char infile[100],image[100],Lut[100],pal_type,label[100];
  190.     int vga_color[256];
  191.     struct Color lut[256],lutm[256],lutc[256];
  192. }Hdr[NUM_IMAGE];
  193. struct Color Qlut[256];
  194. int Scale[NUM_IMAGE][256];
  195. int Range[NUM_IMAGE][3],Reverse[NUM_IMAGE];
  196. char Channel[3][100],ChannelOn=0;
  197. long Sample_Rate=1;
  198. int Img=0,Sample=1,Xc=0,Yc=0,Speed=16,Row,Col,ZoomSample=1,ScreenZoom=1;
  199.  
  200. unsigned char Mbuff[MAX_BUFF],Ibuff[MAX_BUFF],Buffer[4096],OutBuff[1024][4];
  201. int TgaHdr[9]={0,2,0,0,0,0,640,480,32};
  202. unsigned char MaxHues[256][3]=
  203. {
  204. 255,  0,  0,255, 32,  0,255, 42,  0,255, 53,  0,255, 60,  0,255, 68,  0,
  205. 255, 73,  0,255, 80,  0,255, 84,  0,255, 90,  0,255, 94,  0,255,100,  0,
  206. 255,103,  0,255,108,  0,255,112,  0,255,116,  0,255,121,  0,255,124,  0,
  207. 255,128,  0,255,132,  0,255,135,  0,255,139,  0,255,143,  0,255,146,  0,
  208. 255,150,  0,255,154,  0,255,157,  0,255,161,  0,255,164,  0,255,168,  0,
  209. 255,172,  0,255,176,  0,255,179,  0,255,183,  0,255,186,  0,255,190,  0,
  210. 255,194,  0,255,198,  0,255,202,  0,255,206,  0,255,210,  0,255,214,  0,
  211. 255,218,  0,255,222,  0,255,227,  0,255,231,  0,255,236,  0,255,241,  0,
  212. 255,245,  0,255,250,  0,254,255,  0,249,255,  0,244,255,  0,240,255,  0,
  213. 234,255,  0,229,255,  0,224,255,  0,220,255,  0,214,255,  0,209,255,  0,
  214. 204,255,  0,199,255,  0,194,255,  0,190,255,  0,184,255,  0,179,255,  0,
  215. 174,255,  0,169,255,  0,164,255,  0,158,255,  0,152,255,  0,147,255,  0,
  216. 141,255,  0,135,255,  0,130,255,  0,123,255,  0,116,255,  0,109,255,  0,
  217. 102,255,  0, 94,255,  0, 87,255,  0, 78,255,  0, 68,255,  0, 58,255,  0,
  218.  42,255,  0, 23,255,  0,  0,255, 36,  0,255, 58,  0,255, 73,  0,255, 87,
  219.   0,255,101,  0,255,113,  0,255,125,  0,255,135,  0,255,146,  0,255,156,
  220.   0,255,166,  0,255,176,  0,255,186,  0,255,196,  0,255,204,  0,255,214,
  221.   0,255,224,  0,255,233,  0,255,243,  0,255,252,  0,248,255,  0,239,255,
  222.   0,230,255,  0,222,255,  0,214,255,  0,207,255,  0,200,255,  0,194,255,
  223.   0,187,255,  0,181,255,  0,174,255,  0,169,255,  0,163,255,  0,157,255,
  224.   0,152,255,  0,146,255,  0,141,255,  0,136,255,  0,131,255,  0,126,255,
  225.   0,121,255,  0,116,255,  0,111,255,  0,106,255,  0,101,255,  0, 96,255,
  226.   0, 92,255,  0, 86,255,  0, 81,255,  0, 77,255,  0, 71,255,  0, 66,255,
  227.   0, 60,255,  0, 53,255,  0, 48,255,  0, 39,255,  0, 32,255,  0, 23,255,
  228.   0,  0,255, 16,  0,255, 23,  0,255, 28,  0,255, 32,  0,255, 36,  0,255,
  229.  39,  0,255, 42,  0,255, 45,  0,255, 48,  0,255, 50,  0,255, 53,  0,255,
  230.  58,  0,255, 60,  0,255, 62,  0,255, 64,  0,255, 66,  0,255, 68,  0,255,
  231.  70,  0,255, 73,  0,255, 75,  0,255, 77,  0,255, 78,  0,255, 81,  0,255,
  232.  83,  0,255, 84,  0,255, 87,  0,255, 89,  0,255, 92,  0,255, 93,  0,255,
  233.  94,  0,255, 97,  0,255, 98,  0,255,101,  0,255,103,  0,255,105,  0,255,
  234. 107,  0,255,109,  0,255,111,  0,255,113,  0,255,115,  0,255,117,  0,255,
  235. 119,  0,255,122,  0,255,124,  0,255,126,  0,255,129,  0,255,131,  0,255,
  236. 134,  0,255,135,  0,255,138,  0,255,140,  0,255,143,  0,255,145,  0,255,
  237. 148,  0,255,151,  0,255,154,  0,255,156,  0,255,160,  0,255,163,  0,255,
  238. 166,  0,255,169,  0,255,173,  0,255,176,  0,255,179,  0,255,183,  0,255,
  239. 188,  0,255,192,  0,255,196,  0,255,200,  0,255,204,  0,255,209,  0,255,
  240. 214,  0,255,220,  0,255,225,  0,255,231,  0,255,237,  0,255,244,  0,255,
  241. 250,  0,255,255,  0,252,255,  0,245,255,  0,238,255,  0,231,255,  0,224,
  242. 255,  0,217,255,  0,210,255,  0,203,255,  0,196,255,  0,190,255,  0,183,
  243. 255,  0,176,255,  0,170,255,  0,163,255,  0,156,255,  0,151,255,  0,144,
  244. 255,  0,137,255,  0,131,255,  0,125,255,  0,118,255,  0,112,255,  0,105,
  245. 255,  0, 98,255,  0, 90,255,  0, 83,255,  0, 77,255,  0, 68,255,  0, 60,
  246. 255,  0, 50,255,  0, 42,255,  0, 28,255,  0, 23
  247. };
  248.  
  249. char SubType[20];
  250.  
  251. unsigned char getpt();
  252. int set_lut();
  253. double clat();
  254. double clon();
  255. double cx();
  256. double cy();
  257. char fsplit(char *,char *,char *,char *);
  258. FILE *open_to_read_binary(char *);
  259. FILE *open_to_read_text(char *);
  260. FILE *open_to_write_text(char *);
  261. FILE *open_to_write_binary(char *);
  262. long set_time(long);
  263. char set_point();
  264. char change_range();
  265.  
  266. main(argc,argv)
  267.  
  268. int argc;
  269. char *argv[];
  270.  
  271. {
  272.     int i,i1,j,k;
  273.     char string[100],ans;
  274.     int numfile,scan=0;
  275.     FILE *fp;
  276.     char pathbuffer[101];
  277.     long li;
  278.  
  279.     Delay=set_time((long)10000);
  280.     if(argc>1)
  281.     {
  282.         for(i=1;i<argc;i++)
  283.         {
  284.             if(argv[i][1]==':')
  285.                 add_disk_path(argv[i]);
  286.             if(argv[i][0]=='/'&&(argv[i][1]=='O'||argv[i][1]=='o'))
  287.             {
  288.                 OneImage=1;
  289.                 strcpy(OneImageName,argv[i+1]);
  290.             }
  291.             if(argv[i][0]=='/'&&(argv[i][1]=='X'||argv[i][1]=='x'))
  292.                 VideoType='X';
  293.             if(argv[i][0]=='/'&&(argv[i][1]=='Y'||argv[i][1]=='y'))
  294.                 VideoType='Y';
  295.             if(argv[i][0]=='/'&&(argv[i][1]=='E'||argv[i][1]=='e'))
  296.                 VideoType='E';
  297.             if(argv[i][0]=='/'&&(argv[i][1]=='V'||argv[i][1]=='v'))
  298.                 VideoType='V';
  299.             if(argv[i][0]=='/'&&(argv[i][1]=='S'||argv[i][1]=='s'))
  300.             {
  301.                 VideoType='S';
  302.                 FontSize=3;
  303.             }
  304.             if(strcmpi(argv[i],"scan")==0)
  305.                 scan=1;
  306.         }
  307.     }
  308.     if(OneImage==1)
  309.     {
  310.         fp=open_to_read_binary(OneImageName);
  311.         if(!fp)
  312.         {
  313.             printf("Could not open '%s'.\n\n",OneImageName);
  314.             printf("Hit any key to continue.\n\n");
  315.             getch();
  316.             exit(0);
  317.         }
  318.         numfile=0;
  319.         strcpy(Hdr[Img].infile,OneImageName);
  320.     }
  321.     video_on();
  322.     set_lut('G');
  323.     SetVideoMode(0,&B_Id);
  324.  
  325. /* use SubPaths with type of SubType for sub images */
  326.                                     /* move all Path up 1 */
  327.     for(i=NumPath;i>0;i--)
  328.         strcpy(Path[i],Path[i-1]);
  329.     NumPath+=1;
  330.                                     /* add '?mp\' to a new set of Paths */
  331.     for(i=2;i<NumPath;i++)
  332.         sprintf(Path[NumPath+i-2],"%s%s\\",Path[i],SubType+1);
  333.     NumPath+=NumPath-2;
  334.  
  335.     getcwd(pathbuffer,100);
  336.     sprintf(Path[0],"%s\\%s\\",pathbuffer,SubType+1);
  337.     if(scan==1)
  338.     {
  339.         numfile=load_names("*.lbl");
  340.         sort_name(numfile);
  341.         if(numfile>0)
  342.         {
  343.             video_on();
  344.             set_lut('G');
  345.             for(i1=0;i1<numfile;i1++)
  346.             {
  347.                 i=GF_Order[i1];
  348.                 if(read_lbl(GF_File[i].name,0)==1)
  349.                 {
  350.                     if(Hdr[0].pal_type>0)
  351.                     set_lut(Hdr[0].pal_type);
  352.                     else
  353.                     {
  354.                         if(set_lut('P',Hdr[0].Lut)<0)
  355.                             set_lut('G');
  356.                     }
  357.                     Row=Hdr[0].row;
  358.                     Col=Hdr[0].col;
  359.                     Sample=0;
  360.                     do
  361.                     {
  362.                         Sample+=1;
  363.                         Row=Hdr[0].row/Sample;
  364.                         Col=Hdr[0].col/Sample;
  365.                     }while(Col>ScreenXs||Row>ScreenYs);
  366.                     fp=open_to_read_binary(Hdr[0].image);
  367.                     if(fp)
  368.                     {
  369.                         if(plot_full_image(fp,Sample,0)<0)
  370.                             break;
  371.                         fclose(fp);
  372.                         plot_font_h(White,2,2,Hdr[0].image,FontSize,Font);
  373.                         for(li=0;li<Delay;li++);
  374.                     }
  375.                 }
  376.             }
  377.             SetVideoMode(0,&B_Id);
  378.         }
  379.         exit(0);
  380.     }
  381.     do
  382.     {
  383.         if(OneImage==0)
  384.         {
  385.             for(i=0;i<NumPath;i++)
  386.             {
  387.                 strcpy(String,Path[i]);
  388.                 strcat(String,"*.lbl");
  389.         printf("     Use up and down arrow keys, PgUp or\n");
  390.         printf("PgDn, or type the filename to position\n");
  391.         printf("highlighted cursor.  Hit 'Enter' to\n");
  392.         printf("select the file or 'Esc' to leave this\n");
  393.         printf("menu.\n");
  394.         printf("\n");
  395.         printf("     When a box appears on an image use:\n");
  396.         printf("\n");
  397.         printf("     (l)arger or \n");
  398.         printf("     (s)maller \n");
  399.         printf("\n");
  400.         printf("          to change size.\n");
  401.         printf("\n");
  402.         printf("     If the shape of the box can be\n");
  403.         printf("changed use:\n");
  404.         printf("\n");
  405.         printf("     (H)igher,\n");
  406.         printf("     (S)horter,\n");
  407.         printf("     (W)ider, or\n");
  408.         printf("     (N)arrower\n");
  409.         printf("\n");
  410.         printf("          to change shape.\n");
  411.                 numfile=get_file_name(String,Hdr[Img].infile);
  412.                 if(numfile>=0)
  413.                     break;
  414.                 if(numfile<0&&i==NumPath-1)
  415.                 {
  416.                     printf("\n\nHit 'Esc' to quit\n");
  417.                     printf("Any other key to continue\n\n");
  418.                     if(getch()==27)
  419.                         exit(0);
  420.                     i=-1;
  421.                 }
  422.             }
  423.         }
  424.         strcpy(Hdr[Img].label,Hdr[Img].infile);
  425.         if(numfile>=0)
  426.         {
  427.             for(k=0;k<strlen(Hdr[Img].infile);k++)
  428.             if(Hdr[Img].infile[k]=='.')
  429.                 Hdr[Img].infile[k]='\0';
  430.             strcpy(string,Hdr[Img].infile);
  431.             strcat(string,".lbl");        
  432.             if(read_lbl(Hdr[Img].label,Img)==1)
  433.                 process_image(Img);
  434.             else
  435.                 process_set();
  436.         }
  437.         SetVideoMode(0,&B_Id);
  438.     }while(numfile>=0&&OneImage==0);
  439. }
  440.  
  441. /**************************************************************************
  442. **
  443. **
  444. **
  445. ************************************************************************* */
  446.  
  447. int video_on()
  448.  
  449. {
  450.     int i,ret;
  451.  
  452.     i=GetVideoBoardID();
  453.     if(i==0)
  454.         VideoType='E';
  455.     if(i==1&&(VideoType=='X'||VideoType=='Y'))
  456.         VideoType='S';
  457.     if(i<0)
  458.     {
  459.         printf("Computer will not support enough colors.\n\n");
  460.         exit(0);
  461.     }
  462.     if(VideoType=='X')
  463.     {
  464.         SetVideoMode(480,&B_Id);
  465.         if(B_Id.row==480)
  466.         {
  467.             set_lut('G');
  468.             strcpy(SubType,".xmg");
  469.         }
  470.         else
  471.         {
  472.             if(i>1)
  473.                 VideoType='Y';
  474.             else if(i==1)
  475.                 VideoType='V';
  476.             else if(i==0)
  477.                 VideoType='E';
  478.         }
  479.     }
  480.     if(VideoType=='V')
  481.     {
  482.         ret=SetVideoMode(0x12,&B_Id);
  483.         strcpy(SubType,".vmg");
  484.     }
  485.     if(VideoType=='Y')
  486.     {
  487.         ret=SetVideoMode(400,&B_Id);
  488.         strcpy(SubType,".ymg");
  489.     }
  490.     if(VideoType=='S')
  491.     {
  492.         ret=SetVideoMode(0x13,&B_Id);
  493.         set_lut('G');
  494.         strcpy(SubType,".smg");
  495.         FontSize=3;
  496.     }
  497.     if(VideoType=='E')
  498.     {
  499.         ret=SetVideoMode(0x10,&B_Id);
  500.         strcpy(SubType,".emg");
  501.     }
  502.     ScreenXs=B_Id.col;
  503.     ScreenYs=B_Id.row;
  504.     Num_Color=B_Id.color;
  505.     if(ret>=0)
  506.         return(1);
  507.     else
  508.     {
  509.         SetVideoMode(0,&B_Id);
  510.         printf("Could not boot video board\n\n");
  511.         exit(0);
  512.     }
  513. }
  514.  
  515. /***********************************************************************
  516. **
  517. **
  518. **
  519. **
  520. ************************************************************************/
  521.  
  522. int tip(img)
  523. {
  524.  
  525. }
  526.  
  527. /***********************************************************************
  528. **
  529. **
  530. **
  531. **
  532. ************************************************************************/
  533.  
  534. long set_time(delay)
  535.  
  536. long delay;
  537.  
  538. {
  539.     int i,j,k;
  540.     struct timeb t1,t2;
  541.     long li,ds,dm,dt;
  542.  
  543.     ftime(&t1);
  544.     for(li=0;li<delay;li++);
  545.     ftime(&t2);
  546.     ds=t2.time-t1.time;
  547.     dm=(long)t2.millitm-(long)t1.millitm;
  548.     dt=ds*1000+dm;
  549.     if(dt==0)
  550.     {
  551.         delay*=25;
  552.         ftime(&t1);
  553.         for(li=0;li<delay;li++);
  554.         ftime(&t2);
  555.         ds=t2.time-t1.time;
  556.         dm=(long)t2.millitm-(long)t1.millitm;
  557.         dt=ds*1000+dm;
  558.     }
  559.     if(dt>0)
  560.     {
  561.         delay=3000*delay;
  562.         delay/=dt;
  563.     }
  564.     return(delay);
  565. }
  566. /***********************************************************************
  567. **
  568. **
  569. **
  570. **
  571. ************************************************************************/
  572.  
  573. int process_set()
  574.  
  575. {
  576.     int i,j,k;
  577.     char ans,choice[100],string[100];
  578.     int val,val2;
  579.     FILE *fp;
  580.     int sample=0,smp;
  581.     int num=0;
  582.     long li;
  583.     int r,g,b;
  584.     char *fstring[NUM_IMAGE];
  585.     int row=Hdr[0].row,col=Hdr[0].col;
  586.  
  587.     for(k=0;k<3;k++)
  588.     {
  589.         Range[k][0]=0;
  590.         Range[k][1]=127;
  591.         Range[k][2]=255;
  592.     }
  593.     if(VideoType=='X'||VideoType=='Y'||VideoType=='S')
  594.         strcpy(GF_String[num++],"display quick color");
  595.     strcpy(GF_String[num++],"make RGB composit file");
  596.     if(VideoType=='X'||VideoType=='Y'||VideoType=='S')
  597.         strcpy(GF_String[num++],"scale image set");
  598.     strcpy(GF_String[num++],"scan set -- full image");
  599.     if(row>ScreenYs||col>ScreenXs)
  600.         strcpy(GF_String[num++],"scan set -- sub image");
  601.     strcpy(GF_String[num++],"x -- exit set");
  602.     for(i=0;i<Num_Active_Image;i++)
  603.     {
  604.         fstring[i]=Hdr[i].image;
  605.         for(j=0;j<256;j++)
  606.             Scale[i][j]=j;
  607.     }
  608.     i=0;
  609.     Col=Hdr[i].col;
  610.     Row=Hdr[i].row;
  611.     if(Row<=0||Col<=0)
  612.         return(-1);
  613.     video_on();
  614.     set_lut('G');
  615.     do
  616.     {
  617.         Sample=sample+=1;
  618.         Row=Hdr[i].row/sample;
  619.         Col=Hdr[i].col/sample;
  620.     }while(Col>ScreenXs||Row>ScreenYs);
  621.     if(Hdr[i].pal_type>0)
  622.         set_lut(Hdr[i].pal_type);
  623.     else
  624.     {
  625.         if(set_lut('P',Hdr[i].Lut)<0)
  626.             set_lut('G');
  627.     }
  628.     for(i=0;i<Num_Active_Image;i++)
  629.         Hdr[i].sample=sample;
  630.     SetVideoMode(0,&B_Id);
  631.     do
  632.     {
  633.         val=scroll_list_color(40,1,40,21,GF_String,num,choice,23,124,14,63,7);
  634.         if(strcmpi(choice,"make RGB composit file")==0)
  635.         {
  636.             ClearBox(40,79,0,0,3);
  637.             sprintf(string,"Choose RED plane image");
  638.             WriteStringAtxy(40,0,39,(char)4,string);
  639.             r=scroll_any_list(40,1,40,21,fstring,Num_Active_Image,string,
  640.                 71,4,14,63,7);
  641.             if(r<0)
  642.                 return(0);
  643.             sprintf(string,"Choose GREEN plane image");
  644.             WriteStringAtxy(40,0,39,(char)2,string);
  645.             g=scroll_any_list(40,1,40,21,fstring,Num_Active_Image,string,
  646.                 32,2,14,63,7);
  647.             if(g<0)
  648.                 return(0);
  649.             sprintf(string,"Choose BLUE plane image");
  650.             WriteStringAtxy(40,0,39,(char)23,string);
  651.             b=scroll_any_list(40,1,40,21,fstring,Num_Active_Image,string,
  652.                 23,1,14,63,7);
  653.             if(b<0)
  654.                 return(0);
  655.             ClearScreen(0x7);
  656.             printf("Your choices are:\n\n");
  657.             printf("     RED -- '%s'\n",Hdr[r].image);
  658.             printf("   GREEN -- '%s'\n",Hdr[g].image);
  659.             printf("    BLUE -- '%s'\n",Hdr[b].image);
  660.             printf("\nIs this what you want?  (y or n)\n\n");
  661.             ans=getch();
  662.             if(ans=='y')
  663.             {
  664.                 if(scale_rgb(r,g,b)>0)
  665.                 {
  666.                     printf("Input Images:\n");
  667.                     printf("     RED -- '%s'\n",Hdr[r].image);
  668.                     printf("   GREEN -- '%s'\n",Hdr[g].image);
  669.                     printf("    BLUE -- '%s'\n",Hdr[b].image);
  670.                     printf("Give output image file name.\n\n");
  671.                     scanf("%s",string);
  672.                     printf("Give sample rate.  ( 1 = full res 2 = 1/2 size etc.)\n");
  673.                     scanf("%d",&smp);
  674.                     printf("Making 24 bit image file -- 'imvis.cmg'\n");
  675.                     make_cmg_image(r,g,b,smp);
  676.                     fcloseall();
  677.                     execlp("img8bit.exe","img8bit","imvis",string,"5",
  678.                         "/m","10","/c","240",NULL);
  679.                 }
  680.             }
  681.         }
  682.         if(strcmpi(choice,"display quick color")==0)
  683.         {
  684.             ClearBox(40,79,0,0,7);
  685.             sprintf(string,"Choose RED plane image");
  686.             WriteStringAtxy(40,0,39,(char)4,string);
  687.             r=scroll_any_list(40,1,40,21,fstring,Num_Active_Image,string,
  688.                 71,4,14,63,7);
  689.             if(r<0)
  690.                 return(0);
  691.             sprintf(string,"Choose GREEN plane image");
  692.             WriteStringAtxy(40,0,39,(char)2,string);
  693.             g=scroll_any_list(40,1,40,21,fstring,Num_Active_Image,string,
  694.                 32,2,14,63,7);
  695.             if(g<0)
  696.                 return(0);
  697.             sprintf(string,"Choose BLUE plane image");
  698.             WriteStringAtxy(40,0,39,(char)23,string);
  699.             b=scroll_any_list(40,1,40,21,fstring,Num_Active_Image,string,
  700.                 23,1,14,63,7);
  701.             if(b<0)
  702.                 return(0);
  703.             ClearScreen(0x7);
  704.             printf("Your choices are:\n\n");
  705.             printf("     RED -- '%s'\n",Hdr[r].image);
  706.             printf("   GREEN -- '%s'\n",Hdr[g].image);
  707.             printf("    BLUE -- '%s'\n",Hdr[b].image);
  708.             printf("\nIs this what you want?  (y or n)\n\n");
  709.             ans=getch();
  710.             if(ans=='y')
  711.             {
  712.                 load_quick_color_image(r,g,b);
  713.                 getch();
  714.                 SetVideoMode(0,&B_Id);
  715.             }
  716.         }
  717.         if(strcmpi(choice,"scan set -- full image")==0)
  718.         {
  719.             video_on();
  720.             set_lut('G');
  721.             for(i=0;i<Num_Active_Image;i++)
  722.             {
  723.                 if(load_sub_image(i)<0)
  724.                     break;
  725.                 plot_font_h(White,2,2,Hdr[i].image,FontSize,Font);
  726.                 for(li=0;li<Delay;li++);
  727.             }
  728.             SetVideoMode(0,&B_Id);
  729.         }
  730.         if(strcmpi(choice,"scan set -- sub image")==0)
  731.         {
  732.             load_image(0);
  733.             for(i=0;i<Num_Active_Image;i++)
  734.             {
  735.                 fp=open_to_read_binary(Hdr[i].image);
  736.                 if(fp)
  737.                 {
  738.                     if(plot_sub_image(fp,ZoomSample,i)<0)
  739.                         break;
  740.                     plot_font_h(White,2,2,Hdr[i].image,FontSize,Font);
  741.                     for(li=0;li<Delay;li++);
  742.                 }
  743.                 fclose(fp);
  744.             }
  745.             SetVideoMode(0,&B_Id);
  746.         }
  747.         if(strcmpi(choice,"scale image set")==0)
  748.         {
  749.             for(i=0;i<Num_Active_Image;i++)
  750.                 scale(i);
  751.         }
  752.     }while(val>=0&&strcmpi(choice,"x -- exit set")!=0);
  753. }
  754.  
  755. /***********************************************************************
  756. **
  757. **
  758. **
  759. **
  760. ************************************************************************/
  761.  
  762. int scale_rgb(r,g,b)
  763.  
  764. int r,g,b;
  765.  
  766. {
  767.     int i,j,k,m,n;
  768.     int num=0,val,c[3];
  769.     char string[100],choice[100],ans;
  770.     float point[3];
  771.     FILE *fp;
  772.     int dn,num_item,ispeed=2;
  773.     float speed=0.05;
  774.     char *fstring[10];
  775.     int row=Hdr[0].row,col=Hdr[0].col,aimg=0;
  776.  
  777.     point[0]=0.05;
  778.     point[1]=0.50;
  779.     point[2]=0.95;
  780.     strcpy(GF_String[num++],"Use Current Parameters");
  781.     strcpy(GF_String[num++],"Histogram from full image files");
  782.     if(row>ScreenYs||col>ScreenXs)
  783.         strcpy(GF_String[num++],"Histogram from Sub Images");
  784.     strcpy(GF_String[num++],"Input Scale Parameters");
  785.     strcpy(GF_String[num++],"Exit Scale Option");
  786.  
  787.     print_range(r,g,b,point,0);
  788.     for(j=0;j<256;j++)
  789.     {
  790.         Scale[r][j]=j;
  791.         Scale[g][j]=j;
  792.         Scale[b][j]=j;
  793.     }
  794.     do
  795.     {
  796.         c[0]=r;c[1]=g,c[2]=b;
  797.         val=scroll_list_color(40,1,40,21,GF_String,num,choice,63,124,14,63,3);
  798.         if(strcmpi(choice,"Use Current Parameters")==0)
  799.         {
  800.             scale(r);
  801.             scale(g);
  802.             scale(b);
  803.             return(1);
  804.         }
  805.         if(strcmpi(choice,"Histogram from full image files")==0)
  806.         {
  807.             if(load_Fhist("full",c)<0)
  808.                 return(-1);
  809.             set_Range(point,c);
  810.             SetCursor(0,3);
  811.             print_range(r,g,b,point,1);
  812.             scale(r);
  813.             scale(g);
  814.             scale(b);
  815.         }
  816.         if(strcmpi(choice,"Histogram from Sub Images")==0)
  817.         {
  818.             if(load_Fhist("sub",c)<0)
  819.                 return(-1);
  820.             set_Range(point,c);
  821.             SetCursor(0,3);
  822.             print_range(r,g,b,point,1);
  823.             scale(r);
  824.             scale(g);
  825.             scale(b);
  826.         }
  827. /* set scaling for histogram */
  828.         if(strcmpi(choice,"Histogram from full image files")==0||
  829.            strcmpi(choice,"Histogram from Sub Images")==0)
  830.         {
  831.             fstring[0]="Use as is";
  832.             fstring[1]="Change table";
  833.             fstring[2]="Change image";
  834.             num_item=3;
  835.             ClearBox(40,79,0,0,3);
  836.             sprintf(string,"Choose an Option");
  837.             WriteStringAtxy(40,0,39,(char)4,string);
  838.             scroll_any_list(40,1,40,21,fstring,num_item,string,
  839.                 63,4,14,63,7);
  840.             if(strcmpi(string,"Change table")==0)
  841.             {
  842.                 do
  843.                 {
  844.                     ans=set_point(point,&speed);
  845.                     set_Range(point,c);
  846.                     SetCursor(0,3);
  847.                     print_range(r,g,b,point,1);
  848.                 }while(ans!=13&&ans!=27);
  849.                 if(ans!=27)
  850.                 {
  851.                     scale(r);
  852.                     scale(g);
  853.                     scale(b);
  854.                 }
  855.             }
  856.             for(i=0;i<16;i++)
  857.             {
  858.                 Qlut[i].r=Vcolor[i].r;
  859.                 Qlut[i].g=Vcolor[i].g;
  860.                 Qlut[i].b=Vcolor[i].b;
  861.             }
  862.             if(strcmpi(string,"Change image")==0)
  863.             {
  864.                 for(i=0;i<64;i++)
  865.                 {
  866.                     for(k=0;k<3;k++)
  867.                     {
  868.                         Qlut[i+(k+1)*64].r=i*4;
  869.                         Qlut[i+(k+1)*64].g=i*4;
  870.                         Qlut[i+(k+1)*64].b=i*4;
  871.                     }
  872.                 }
  873.                 video_on();
  874.                 WritePalette(Qlut);
  875.                 plot_image(r,0,0,64,RED);
  876.                 plot_image(g,ScreenXs/2,0,128,GREEN);
  877.                 plot_image(b,0,ScreenYs/2,192,BLUE);
  878.                 plot_Range(ScreenXs/2,ScreenYs/2,c,aimg);
  879.                 getch();
  880.                 point[0]=0.01;point[1]=0.50;point[2]=0.99;
  881.                 set_Range(point,c);
  882.                 scale(r);
  883.                 scale(g);
  884.                 scale(b);
  885.                 for(i=0;i<64;i++)
  886.                 {
  887.                     for(k=0;k<3;k++)
  888.                     {
  889.                         Qlut[i+(k+1)*64].r=Scale[c[k]][i*4];
  890.                         Qlut[i+(k+1)*64].g=Scale[c[k]][i*4];
  891.                         Qlut[i+(k+1)*64].b=Scale[c[k]][i*4];
  892.                     }
  893.                 }
  894.                 WritePalette(Qlut);
  895.                 do
  896.                 {
  897.                     ans=change_range(&aimg,c,&ispeed);
  898.                     if(ans=='r'||ans=='R')
  899.                     {
  900.                         set_Range(point,c);
  901.                         scale(r);
  902.                         scale(g);
  903.                         scale(b);
  904.                         for(i=0;i<64;i++)
  905.                         {
  906.                             for(k=0;k<3;k++)
  907.                             {
  908.                                 Qlut[i+(k+1)*64].r=Scale[c[k]][i*4];
  909.                                 Qlut[i+(k+1)*64].g=Scale[c[k]][i*4];
  910.                                 Qlut[i+(k+1)*64].b=Scale[c[k]][i*4];
  911.                             }
  912.                         }
  913.                     }                        
  914.                     else
  915.                     {
  916.                         scale(c[aimg]);
  917.                         k=aimg;
  918.                         for(i=0;i<64;i++)
  919.                         {
  920.                             Qlut[i+(k+1)*64].r=Scale[c[k]][i*4];
  921.                             Qlut[i+(k+1)*64].g=Scale[c[k]][i*4];
  922.                             Qlut[i+(k+1)*64].b=Scale[c[k]][i*4];
  923.                         }
  924.                     }
  925.                     WritePalette(Qlut);
  926.                     plot_Range(ScreenXs/2,ScreenYs/2,c,aimg);
  927.                 }while(ans!=27);
  928.                 SetVideoMode(0,&B_Id);
  929.             }
  930.         }
  931.     }while(val>=0&&strcmpi(choice,"Exit Scale Option")!=0);
  932.     return(1);
  933. }
  934.  
  935. /***********************************************************************
  936. **
  937. **
  938. **
  939. **
  940. ************************************************************************/
  941.  
  942. char change_range(img,c,speed)
  943.  
  944. int *img,*c,*speed;
  945.  
  946. {
  947.     int i,j,k=*img;
  948.     char ans;
  949.  
  950.     ans=getch();
  951.     if(ans=='n'||ans=='N')
  952.     {
  953.         if(Reverse[c[k]]==0)
  954.             Reverse[c[k]]=1;
  955.         else
  956.             Reverse[c[k]]=0;
  957.     }
  958.     if(ans==13)
  959.     {
  960.         if(k<2)
  961.             k+=1;
  962.         else
  963.             k=0;
  964.     }
  965.     if(ans==8)
  966.     {
  967.         if(k>0)
  968.             k-=1;
  969.         else
  970.             k=2;
  971.     }
  972.     if(ans==0)
  973.     {
  974.         ans=getch();
  975.         if(ans==71)Range[c[k]][0]+=*speed;
  976.         if(ans==72)Range[c[k]][1]+=*speed;
  977.         if(ans==73)Range[c[k]][2]+=*speed;
  978.         if(ans==79)Range[c[k]][0]-=*speed;
  979.         if(ans==80)Range[c[k]][1]-=*speed;
  980.         if(ans==81)Range[c[k]][2]-=*speed;
  981.     }
  982.     else
  983.     {
  984.         if(ans=='7')Range[c[k]][0]+=*speed;
  985.         if(ans=='8')Range[c[k]][1]+=*speed;
  986.         if(ans=='9')Range[c[k]][2]+=*speed;
  987.         if(ans=='1')Range[c[k]][0]-=*speed;
  988.         if(ans=='2')Range[c[k]][1]-=*speed;
  989.         if(ans=='3')Range[c[k]][2]-=*speed;
  990.     }
  991.     for(i=0;i<3;i++)
  992.     {
  993.         if(Range[c[k]][i]<0)Range[c[k]][i]=0;
  994.         if(Range[c[k]][i]>255)Range[c[k]][i]=255;
  995.     }
  996.     if(ans=='+'&&*speed<16)
  997.         *speed*=2;
  998.     if(ans=='-'&&*speed>1)
  999.         *speed/=2;
  1000.     *img=k;
  1001.     return(ans);
  1002. }
  1003.  
  1004.  
  1005.  
  1006. /***********************************************************************
  1007. **
  1008. **
  1009. **
  1010. ************************************************************************/
  1011.  
  1012. int plot_Range(xc,yc,c,on)
  1013.  
  1014. int xc,yc,*c,on;
  1015.  
  1016. {
  1017.     int i,j,k;
  1018.     int xs=ScreenXs/2,ys=ScreenYs/2;
  1019.     char string[100];
  1020.     int color[3];
  1021.  
  1022.     color[0]=RED;color[1]=GREEN;color[2]=BLUE;
  1023.     for(k=0;k<3;k++)
  1024.     {
  1025.         if(Reverse[c[k]]==0)
  1026.             sprintf(string,"%3d %3d %3d  ",
  1027.                 Range[c[k]][0],Range[c[k]][1],Range[c[k]][2]);
  1028.         else
  1029.             sprintf(string,"%3d %3d %3d N",
  1030.                 Range[c[k]][0],Range[c[k]][1],Range[c[k]][2]);
  1031.         if(on==k)
  1032.         {
  1033.             paint_box(0,BLACK,Mbuff,xc+3,yc+3+k*45/FontSize,
  1034.                 strlen(string)*15/FontSize+10,32/FontSize);
  1035.             box(0,xc+3,yc+3+k*45/FontSize,WHITE,
  1036.                 strlen(string)*15/FontSize+19,32/FontSize-1);
  1037.         }
  1038.         else
  1039.             paint_box(0,D_GREY,Mbuff,xc+3,yc+3+k*45/FontSize,
  1040.                 strlen(string)*15/FontSize+20,32/FontSize);
  1041.         plot_font_h(color[k],xc+10,yc+5+k*45/FontSize,string,FontSize,Font);
  1042.     }
  1043. }
  1044.  
  1045.  
  1046.  
  1047. /***********************************************************************
  1048. **
  1049. **
  1050. **
  1051. **
  1052. ************************************************************************/
  1053.  
  1054. char set_point(point,speed)
  1055.  
  1056. float *point,*speed;
  1057.  
  1058. {
  1059.     int k;
  1060.     char ans;
  1061.  
  1062.     ans=getch();
  1063.     if(ans==0)
  1064.     {
  1065.         ans=getch();
  1066.         if(ans==71)point[0]+=*speed;
  1067.         if(ans==72)point[1]+=*speed;
  1068.         if(ans==73)point[2]+=*speed;
  1069.         if(ans==79)point[0]-=*speed;
  1070.         if(ans==80)point[1]-=*speed;
  1071.         if(ans==81)point[2]-=*speed;
  1072.     }
  1073.     else
  1074.     {
  1075.         if(ans=='7')point[0]+=*speed;
  1076.         if(ans=='8')point[1]+=*speed;
  1077.         if(ans=='9')point[2]+=*speed;
  1078.         if(ans=='1')point[0]-=*speed;
  1079.         if(ans=='2')point[1]-=*speed;
  1080.         if(ans=='3')point[2]-=*speed;
  1081.     }
  1082.     for(k=0;k<3;k++)
  1083.     {
  1084.         if(point[k]<0.001)point[k]=0.001;
  1085.         if(point[k]>1.000)point[k]=1.000;
  1086.     }
  1087.     if(ans=='+'&&*speed<0.1)
  1088.         *speed*=2.0;
  1089.     if(ans=='-'&&*speed>0.01)
  1090.         *speed/=2.0;
  1091.     return(ans);
  1092. }
  1093.  
  1094.  
  1095.  
  1096. /***********************************************************************
  1097. **
  1098. **
  1099. **
  1100. ***********************************************************************/
  1101. int set_Range(point,c)
  1102.  
  1103. float *point;
  1104. int *c;
  1105.  
  1106. {
  1107.     int i,j,k;
  1108.     int dn;
  1109.  
  1110.     for(k=0;k<3;k++)
  1111.     {
  1112.         Fsum[k]=0.0;
  1113.         Range[c[k]][0]=Range[c[k]][1]=Range[c[k]][2]=-1;
  1114.         for(dn=0;dn<256;dn++)
  1115.         {
  1116.             Fsum[k]+=Fhist[k][dn]/Ftot[k];
  1117.             for(i=0;i<3;i++)
  1118.                 if(Range[c[k]][i]<0&&Fsum[k]>=point[i])
  1119.                     Range[c[k]][i]=dn;
  1120.         }
  1121.     }
  1122. }
  1123.  
  1124.  
  1125.  
  1126. /***********************************************************************
  1127. **
  1128. **
  1129. **
  1130. ***********************************************************************/
  1131.  
  1132. int load_Fhist(type,c)
  1133.  
  1134. char *type;
  1135. int *c;
  1136.  
  1137. {
  1138.     int i,j,k,m,n;
  1139.     int dn,row,col;
  1140.     char string[100],cr=0xd;
  1141.     FILE *fp;
  1142.  
  1143.     for(k=0;k<3;k++)
  1144.     {
  1145.         for(dn=0;dn<256;dn++)
  1146.             Fhist[k][dn]=0;
  1147.         Ftot[k]=0;
  1148.         if(strcmpi(type,"full")==0)
  1149.         {
  1150.             strcpy(string,Hdr[c[k]].image);
  1151.             if(strlen(string)<1)
  1152.             {
  1153.                 printf("Bad file name -- too short!\n\n");
  1154.                 return(-1);
  1155.             }
  1156.             if(strlen(string)>99)
  1157.             {
  1158.                 printf("Bad file name -- too long!\n\n");
  1159.                 exit(0);
  1160.             }
  1161.             fp=open_to_read_binary(string);
  1162.             if(!fp)
  1163.             {
  1164.                 printf("Could not find '%s'.\n",string);
  1165.                 return(-1);
  1166.             }
  1167.             row=Hdr[0].row;
  1168.             col=Hdr[0].col;
  1169.             fseek(fp,Hdr[0].header_bytes,SEEK_SET);
  1170.         }
  1171.         else if(strcmpi(type,"sub")==0)
  1172.         {
  1173.             strcpy(string,Hdr[c[k]].image);
  1174.             if(strlen(string)<1)
  1175.             {
  1176.                 printf("Bad file name -- too short!\n\n");
  1177.                 return(-1);
  1178.             }
  1179.             if(strlen(string)>99)
  1180.             {
  1181.                 printf("Bad file name -- too long!\n\n");
  1182.                 exit(0);
  1183.             }
  1184.             for(m=0;m<strlen(string);m++)
  1185.             if(string[m]=='.')
  1186.                 string[m]='\0';
  1187.             strcat(string,SubType);
  1188.             fp=open_to_read_binary(string);
  1189.             if(!fp)
  1190.             {
  1191.                 printf("Could not find '%s'.  Try viewing image to create it\n",
  1192.                     string);
  1193.                 printf("or try full image option.\n\n");
  1194.                 return(-1);
  1195.             }
  1196.             fread((char *)&row,sizeof(int),1,fp);
  1197.             fread((char *)&col,sizeof(int),1,fp);
  1198.         }
  1199.         else
  1200.             return(-1);    
  1201.         printf("Processing '%s'\n       of %d lines",string,row);
  1202.         for(i=0;i<row;i++)
  1203.         {
  1204.             printf("%c%6d",cr,i+1);
  1205.             for(j=0;j<col;j++)
  1206.             {
  1207.                 dn=fgetc(fp);
  1208.                 Fhist[k][dn]+=1.0;
  1209.                 Ftot[k]+=1.0;
  1210.             }
  1211.         }
  1212.         printf("\n");
  1213.         fclose(fp);
  1214.     }
  1215.     return(1);
  1216. }
  1217.  
  1218.  
  1219.  
  1220. /***********************************************************************
  1221. **
  1222. **
  1223. **
  1224. ***********************************************************************/
  1225.  
  1226. int plot_image(img,xc,yc,base,color)
  1227.  
  1228. int img,xc,yc,base,color;
  1229.  
  1230. {
  1231.     int i,j,k;
  1232.     int row=Hdr[0].row,col=Hdr[0].col;
  1233.     char string[100],filename[100];
  1234.     FILE *fp;
  1235.     long offset;
  1236.  
  1237.     if(row>ScreenYs||col>ScreenXs)    /* use sample image */
  1238.     {
  1239.         strcpy(string,Hdr[img].image);
  1240.         for(k=0;k<strlen(string);k++)
  1241.             if(string[k]=='.')
  1242.                 string[k]='\0';
  1243.         strcat(string,SubType);
  1244.         fp=open_to_read_binary(string);
  1245.         if(!fp)
  1246.         {
  1247.             printf("Could not find '%s'.  Try viewing image to create it\n",
  1248.                 string);
  1249.             printf("or try full image option.\n\n");
  1250.             return(-1);
  1251.         }
  1252.         fread((char *)&row,sizeof(int),1,fp);
  1253.         fread((char *)&col,sizeof(int),1,fp);
  1254.     }
  1255.     else
  1256.     {
  1257.         fp=open_to_read_binary(Hdr[img].image);
  1258.         if(!fp)
  1259.         {
  1260.             printf("Could not find '%s'\n",
  1261.                 Hdr[img].image);
  1262.             return(-1);
  1263.         }
  1264.         fseek(fp,Hdr[img].header_bytes,SEEK_SET);
  1265.     }
  1266.     offset=col;
  1267.     for(i=0;i<row/2;i++)
  1268.     {
  1269.         fread((char *)Mbuff,sizeof(char),col,fp);
  1270.         for(j=0;j<col/2;j++)
  1271.             Mbuff[j]=Mbuff[j*2]/4+base;
  1272.         plotrow(0,xc,xc+col/2-1,yc+i,Mbuff);
  1273.         fseek(fp,offset,SEEK_CUR);
  1274.     }
  1275.     sprintf(string,"%s",Hdr[img].image);
  1276.     paint_box(0,D_GREY,Mbuff,xc,yc,strlen(string)*15/FontSize,30/FontSize);
  1277.     plot_font_h(color,xc+1,yc+1,string,FontSize,Font);
  1278. }
  1279.  
  1280.  
  1281.  
  1282.  
  1283.  
  1284. /***********************************************************************
  1285. **
  1286. **   iop = 0 do not print Change info
  1287. **         1 print percentile
  1288. **
  1289. **
  1290. ************************************************************************/
  1291.  
  1292. int print_range(r,g,b,point,iop)
  1293.  
  1294. int r,g,b;
  1295. float *point;
  1296. int iop;
  1297.  
  1298. {
  1299.     printf("\n\n");
  1300.     printf("--------------------------------------\n");
  1301.     printf("        Current Scaling Parameters    \n");
  1302.     printf("--------------------------------------\n");
  1303.     printf("       Minimum   Mid-Point   Maximum  \n");
  1304.     printf("----- ---------- ---------- ----------\n");
  1305.     printf("  red%7d%11d%11d    \n",Range[r][0],Range[r][1],Range[r][2]);
  1306.     printf("green%7d%11d%11d    \n",Range[g][0],Range[g][1],Range[g][2]);
  1307.     printf(" blue%7d%11d%11d    \n",Range[b][0],Range[b][1],Range[b][2]);
  1308.     printf("\n\n");
  1309.     if(iop==1)
  1310.     {
  1311.         printf("------------ ---------- --------------\n");
  1312.         printf("Use 'Number Pad' to change percentiles\n");
  1313.         printf("------------ ---------- --------------\n");
  1314.         printf("up       7          8          9\n");
  1315.         printf("------------ ---------- --------------\n");
  1316.         printf("%12.2f%11.2f%11.2f    percentile\n",point[0],point[1],point[2]);
  1317.         printf("------------ ---------- --------------\n");
  1318.         printf("down     1          2          3\n");
  1319.         printf("------------ ---------- --------------\n");
  1320.     }
  1321. }
  1322.  
  1323.  
  1324.  
  1325.  
  1326. /***********************************************************************
  1327. **
  1328. **
  1329. **
  1330. **
  1331. ************************************************************************/
  1332.  
  1333. int scale(img)
  1334.  
  1335. int img;
  1336.  
  1337. {
  1338.     int i,j,k;
  1339.     long n1=Range[img][0],n2=Range[img][1],n3=Range[img][2];
  1340.     long dn1=n2-n1,dn2=n3-n2;
  1341.     long val;
  1342.  
  1343.     if(dn1<2||dn2<2)
  1344.         return(0);
  1345.  
  1346.     for(i=0;i<n1;i++)
  1347.         Scale[img][i]=0;
  1348.     for(i=n3;i<256;i++)
  1349.         Scale[img][i]=255;
  1350.     for(i=n1;i<n2;i++)
  1351.     {
  1352.         val=i-n1;
  1353.         val*=127;
  1354.         val/=dn1;
  1355.         Scale[img][i]=val;
  1356.     }
  1357.     for(i=n2;i<n3;i++)
  1358.     {
  1359.         val=i-n2;
  1360.         val*=127;
  1361.         val/=dn2;
  1362.         val+=128;
  1363.         Scale[img][i]=val;
  1364.     }
  1365.     if(Reverse[img]==1)
  1366.         for(i=0;i<256;i++)
  1367.             Scale[img][i]=255-Scale[img][i];
  1368. }
  1369.  
  1370.  
  1371.  
  1372. /***********************************************************************
  1373. **
  1374. **
  1375. **
  1376. **
  1377. ************************************************************************/
  1378.  
  1379. int make_cmg_image(r,g,b,sample)
  1380.  
  1381. int r,g,b,sample;
  1382.  
  1383. {
  1384.     int i,j,k;
  1385.     int row=Hdr[0].row,col=Hdr[0].col;
  1386.     int nrow,ncol;
  1387.     FILE *fpred,*fpgrn,*fpblu,*fpcmg,*fpchn;
  1388.     unsigned char *rbuff,*gbuff,*bbuff;
  1389.     char cr=0xd;
  1390.     long offset=(long)col*(long)(sample-1);
  1391.  
  1392.     if(sample<1)
  1393.         return(0);
  1394.     printf("sample = %d  offset = %ld\n",sample,offset);
  1395.     nrow=row/sample;
  1396.     ncol=col/sample;
  1397.     rbuff=Mbuff;
  1398.     gbuff=Mbuff+col;
  1399.     bbuff=Mbuff+col*2;
  1400.     fpred=open_to_read_binary(Hdr[r].image);
  1401.     if(!fpred)
  1402.     {
  1403.         fcloseall();
  1404.         return(-1);
  1405.     }
  1406.     fpgrn=open_to_read_binary(Hdr[g].image);
  1407.     if(!fpgrn)
  1408.     {
  1409.         fcloseall();
  1410.         return(-1);
  1411.     }
  1412.     fpblu=open_to_read_binary(Hdr[b].image);
  1413.     if(!fpblu)
  1414.     {
  1415.         fcloseall();
  1416.         return(-1);
  1417.     }
  1418.                             /* make a file (imvis.chn) with file names */
  1419.     fpchn=fopen("imvis.chn","wt");
  1420.     if(fpchn)
  1421.     {
  1422.         fprintf(fpchn,"SAMPLE_RATE = %d\n",sample);
  1423.         fprintf(fpchn,"CHANNEL_INPUT:\n");
  1424.         if(Reverse[r]==0)
  1425.             fprintf(fpchn,"     RED   = %s Range = %3d %3d %3d\n",
  1426.                 Hdr[r].image,Range[r][0],Range[r][1],Range[r][2]);
  1427.         else
  1428.             fprintf(fpchn,"     RED   = %s Range = %3d %3d %3d (Negative)\n",
  1429.                 Hdr[r].image,Range[r][0],Range[r][1],Range[r][2]);
  1430.         if(Reverse[g]==0)
  1431.             fprintf(fpchn,"     GREEN = %s Range = %3d %3d %3d\n",
  1432.                 Hdr[g].image,Range[g][0],Range[g][1],Range[g][2]);
  1433.         else
  1434.             fprintf(fpchn,"     GREEN = %s Range = %3d %3d %3d (Negative)\n",
  1435.                 Hdr[g].image,Range[g][0],Range[g][1],Range[g][2]);
  1436.         if(Reverse[b]==0)
  1437.             fprintf(fpchn,"     BLUE  = %s Range = %3d %3d %3d\n",
  1438.                 Hdr[b].image,Range[b][0],Range[b][1],Range[b][2]);
  1439.         else
  1440.             fprintf(fpchn,"     BLUE  = %s Range = %3d %3d %3d (Negative)\n",
  1441.                 Hdr[b].image,Range[b][0],Range[b][1],Range[b][2]);
  1442.         fclose(fpchn);
  1443.     }
  1444.     fpcmg=fopen("imvis.cmg","wb");
  1445.     if(!fpcmg)
  1446.     {
  1447.         fcloseall();
  1448.         return(-1);
  1449.     }
  1450.     fseek(fpred,Hdr[r].header_bytes,SEEK_SET);
  1451.     fseek(fpgrn,Hdr[g].header_bytes,SEEK_SET);
  1452.     fseek(fpblu,Hdr[b].header_bytes,SEEK_SET);
  1453.  
  1454.     fwrite((char *)&nrow,sizeof(int),1,fpcmg);
  1455.     fwrite((char *)&ncol,sizeof(int),1,fpcmg);
  1456.     printf("      of %d",row/sample);
  1457.     for(i=0;i<row/sample;i++)
  1458.     {
  1459.         printf("%c%5d",cr,i+1);
  1460.         fread((char *)rbuff,sizeof(char),col,fpred);
  1461.         fread((char *)gbuff,sizeof(char),col,fpgrn);
  1462.         fread((char *)bbuff,sizeof(char),col,fpblu);
  1463.         if(sample>1)
  1464.         {
  1465.             fseek(fpred,offset,SEEK_CUR);
  1466.             fseek(fpgrn,offset,SEEK_CUR);
  1467.             fseek(fpblu,offset,SEEK_CUR);
  1468.             for(j=0;j<col/sample;j++)
  1469.             {
  1470.                 rbuff[j]=Scale[r][rbuff[j*sample]];
  1471.                 gbuff[j]=Scale[g][gbuff[j*sample]];
  1472.                 bbuff[j]=Scale[b][bbuff[j*sample]];
  1473.             }    
  1474.         }
  1475.         else
  1476.         {
  1477.             for(j=0;j<col;j++)
  1478.             {
  1479.                 rbuff[j]=Scale[r][rbuff[j]];
  1480.                 gbuff[j]=Scale[g][gbuff[j]];
  1481.                 bbuff[j]=Scale[b][bbuff[j]];
  1482.             }    
  1483.         }
  1484.         fwrite((char *)rbuff,sizeof(char),col/sample,fpcmg);
  1485.         fwrite((char *)gbuff,sizeof(char),col/sample,fpcmg);
  1486.         fwrite((char *)bbuff,sizeof(char),col/sample,fpcmg);
  1487.     }
  1488.     printf("\n");
  1489.     fcloseall();
  1490. }
  1491.  
  1492.  
  1493.  
  1494.  
  1495.  
  1496. /**************************************************************************
  1497. **
  1498. **
  1499. **
  1500. ************************************************************************* */
  1501.  
  1502. int load_quick_color_image(r,g,b)
  1503.  
  1504. int r,g,b;
  1505.  
  1506. {
  1507.     int i,j,k;
  1508.     int ir,ig,ib;
  1509.     int qr=7,qg=7,qb=5;
  1510.     int dr=255/qr+1,dg=255/qg+1,db=255/qb+1;
  1511.     int xr=255/(qr-1),xg=255/(qg-1),xb=255/(qg-1);
  1512.     int sample=0;
  1513.     int xs,ys;
  1514.     FILE *fpred,*fpgrn,*fpblu;
  1515.     long offset=0;
  1516.     char string[100];
  1517.     int filenum=0;
  1518.  
  1519.     fpred=open_to_read_binary(Hdr[r].image);
  1520.     if(!fpred)
  1521.     {
  1522.         fcloseall();
  1523.         return(-1);
  1524.     }
  1525.     fpgrn=open_to_read_binary(Hdr[g].image);
  1526.     if(!fpgrn)
  1527.     {
  1528.         fcloseall();
  1529.         return(-1);
  1530.     }
  1531.     fpblu=open_to_read_binary(Hdr[b].image);
  1532.     if(!fpblu)
  1533.     {
  1534.         fcloseall();
  1535.         return(-1);
  1536.     }
  1537.     for(ir=0;ir<qr;ir++)
  1538.         for(ig=0;ig<qg;ig++)
  1539.             for(ib=0;ib<qb;ib++)
  1540.             {
  1541.                 i=ir*(qg*qb)+ig*qb+ib;
  1542.                 Qlut[i].r=ir*xr;
  1543.                 Qlut[i].g=ig*xg;
  1544.                 Qlut[i].b=ib*xb;
  1545.             }
  1546.     Row=Hdr[filenum].row;
  1547.     Col=Hdr[filenum].col;
  1548.     if(VideoType=='S')
  1549.         Speed=8;
  1550.     if(Hdr[filenum].sample_bits==0)
  1551.         Hdr[filenum].sample_bits=8;
  1552.     if((Row==0||Col==0)&&Hdr[filenum].row_col_header==0)
  1553.         return(-1);
  1554.     video_on();
  1555.     WritePalette(Qlut);
  1556.     do
  1557.     {
  1558.         Sample=sample+=1;
  1559.         Row=Hdr[filenum].row/sample;
  1560.         Col=Hdr[filenum].col/sample;
  1561.     }while(Col>ScreenXs||Row>ScreenYs);
  1562.     Hdr[filenum].sample=sample;
  1563.     fcloseall();
  1564.     plot_full_qc_image(sample,r,g,b,qr,qg,qb);
  1565. /*
  1566.     if(sample>1)
  1567.     {
  1568.         sample=ZoomSample;
  1569.         if(limit_area_fixed(&Xc,&Yc,&xs,&ys,&Speed,&sample)!=27)
  1570.         {
  1571.             ZoomSample=sample;
  1572.             plot_sub_qc_image(fp,sample,filenum);
  1573.         }
  1574.         else
  1575.         {
  1576.             ZoomSample=Sample;
  1577.         }
  1578.     }
  1579. */
  1580. }
  1581.  
  1582.  
  1583. /**************************************************************************
  1584. **
  1585. **
  1586. **
  1587. ************************************************************************* */
  1588.  
  1589. int plot_full_qc_image(sample,r,g,b,qr,qg,qb)
  1590.  
  1591. int sample,r,g,b,qr,qg,qb;
  1592.  
  1593. {
  1594.     int i,j,k;
  1595.     int ir,ig,ib;
  1596.     long offset;
  1597.     char string[100];
  1598.     int row,col,val,filenum=0;
  1599.     FILE *fpsubr,*fpsubg,*fpsubb,*fpr,*fpg,*fpb;
  1600.     int dr=255/qr+1,dg=255/qg+1,db=255/qb+1;
  1601.     int xr=255/(qr-1),xg=255/(qg-1),xb=255/(qg-1);
  1602.     unsigned offsetr,offsetg,offsetb;
  1603.  
  1604.     strcpy(string,Hdr[r].image);
  1605.     for(i=0;i<strlen(string);i++)
  1606.         if(string[i]=='.')
  1607.             string[i]='\0';
  1608.     strcat(string,SubType);
  1609.     fpsubr=open_to_read_binary(string);
  1610.     strcpy(string,Hdr[g].image);
  1611.     for(i=0;i<strlen(string);i++)
  1612.         if(string[i]=='.')
  1613.             string[i]='\0';
  1614.     strcat(string,SubType);
  1615.     fpsubg=open_to_read_binary(string);
  1616.     strcpy(string,Hdr[b].image);
  1617.     for(i=0;i<strlen(string);i++)
  1618.         if(string[i]=='.')
  1619.             string[i]='\0';
  1620.     strcat(string,SubType);
  1621.     fpsubb=open_to_read_binary(string);
  1622.     if(fpsubr&&fpsubg&&fpsubb)
  1623.     {
  1624.         fread((char *)&row,sizeof(int),1,fpsubr);
  1625.         fread((char *)&col,sizeof(int),1,fpsubr);
  1626.         fread((char *)&row,sizeof(int),1,fpsubg);
  1627.         fread((char *)&col,sizeof(int),1,fpsubg);
  1628.         fread((char *)&row,sizeof(int),1,fpsubb);
  1629.         fread((char *)&col,sizeof(int),1,fpsubb);
  1630.         offsetr=0;
  1631.         offsetb=col;
  1632.         offsetg=col*2;
  1633.         for(i=0;i<row;i++)
  1634.         {
  1635.             fread((char *)Mbuff+offsetr,sizeof(char),col,fpsubr);
  1636.             fread((char *)Mbuff+offsetg,sizeof(char),col,fpsubg);
  1637.             fread((char *)Mbuff+offsetb,sizeof(char),col,fpsubb);
  1638.             if(kbhit()>0)
  1639.             {
  1640.                 val=getch();
  1641.                 if(val==27)
  1642.                     return(-2);
  1643.             }
  1644.             for(j=0;j<col;j++)
  1645.             {
  1646.                 ir=Scale[r][Mbuff[j+offsetr]]/dr;
  1647.                 ig=Scale[g][Mbuff[j+offsetg]]/dg;
  1648.                 ib=Scale[b][Mbuff[j+offsetb]]/db;
  1649.                 k=ir*(qg*qb)+ig*qb+ib;
  1650.                 Mbuff[j]=k;
  1651.             }
  1652.             plotrow(0,0,col-1,i,Mbuff);
  1653.         }
  1654.     }
  1655.     else
  1656.     {
  1657.         fclose(fpsubr);
  1658.         fclose(fpsubg);
  1659.         fclose(fpsubb);
  1660.         fpr=open_to_read_binary(Hdr[r].image);
  1661.         fpg=open_to_read_binary(Hdr[g].image);
  1662.         fpb=open_to_read_binary(Hdr[b].image);
  1663.         if(fpr&&fpg&&fpb)
  1664.         {
  1665.             offset=Hdr[r].header_bytes;
  1666.                 if(offset>0)
  1667.                     fseek(fpr,offset,SEEK_SET);
  1668.             offset=Hdr[g].header_bytes;
  1669.                 if(offset>0)
  1670.                     fseek(fpg,offset,SEEK_SET);
  1671.             offset=Hdr[b].header_bytes;
  1672.                 if(offset>0)
  1673.                     fseek(fpb,offset,SEEK_SET);
  1674.             offset=(sample-1);
  1675.             offset*=Hdr[r].col;
  1676.             for(i=0;i<Row;i++)
  1677.             {
  1678.                 fread((char *)Mbuff+offsetr,sizeof(char),Hdr[r].col,fpr);
  1679.                 fread((char *)Mbuff+offsetg,sizeof(char),Hdr[g].col,fpg);
  1680.                 fread((char *)Mbuff+offsetb,sizeof(char),Hdr[b].col,fpb);
  1681.                 if(kbhit()>0)
  1682.                 {
  1683.                     val=getch();
  1684.                     if(val==27)
  1685.                         return(-2);
  1686.                 }
  1687.                 if(offset>0)
  1688.                 {
  1689.                     fseek(fpr,offset,SEEK_CUR);
  1690.                     fseek(fpg,offset,SEEK_CUR);
  1691.                     fseek(fpb,offset,SEEK_CUR);
  1692.                 }
  1693.                 if(sample>1)
  1694.                 {
  1695.                     for(j=0;j<Col;j++)
  1696.                     {
  1697.                         ir=Scale[r][Mbuff[j*sample+offsetr]]/dr;
  1698.                         ig=Scale[g][Mbuff[j*sample+offsetg]]/dg;
  1699.                         ib=Scale[b][Mbuff[j*sample+offsetb]]/db;
  1700.                         k=ir*(qg*qb)+ig*qb+ib;
  1701.                         Mbuff[j]=k;
  1702.                     }
  1703.                 }
  1704.                 else
  1705.                 {
  1706.                     for(j=0;j<Col;j++)
  1707.                     {
  1708.                         ir=Scale[r][Mbuff[j+offsetr]]/dr;
  1709.                         ig=Scale[g][Mbuff[j+offsetg]]/dg;
  1710.                         ib=Scale[b][Mbuff[j+offsetb]]/db;
  1711.                         k=ir*(qg*qb)+ig*qb+ib;
  1712.                         Mbuff[j]=k;
  1713.                     }
  1714.                 }
  1715.                 plotrow(3,0,Col-1,i,Mbuff);
  1716.             }
  1717.             fclose(fpr);
  1718.             fclose(fpg);
  1719.             fclose(fpb);
  1720.         }
  1721.     }
  1722.     fclose(fpsubr);
  1723.     fclose(fpsubg);
  1724.     fclose(fpsubb);
  1725. }
  1726.  
  1727.  
  1728. /********************************************************************
  1729. **
  1730. **
  1731. **
  1732. ********************************************************************* */
  1733.  
  1734. int scroll_any_list(xc,yc,xs,ys,string,num,out_string,
  1735.         menu,cursor,box,highlight,base)
  1736.  
  1737. int xc,yc,xs,ys,num;
  1738. char *string[],*out_string;
  1739. int menu,cursor,box,highlight,base;
  1740.  
  1741. {
  1742.     int i,j,k;
  1743.     int x1=xc,x2=xc+xs-1,y1=yc,y2=yc+ys-1;
  1744.     int n=0,n1,n2,nlines=ys-2,no;
  1745.     char instring[NAME_SIZE];
  1746.     char ans,ansc;
  1747.  
  1748.     if(num<ys-2)
  1749.     {
  1750.         ys=num+2;
  1751.         y2=yc+ys-1;
  1752.         nlines=ys-2;
  1753.     }
  1754.     n1=n-nlines/2;
  1755.     if(n1<0)n1=0;
  1756.     n2=n1+nlines-1;
  1757.     if(n2>num-1)
  1758.     {
  1759.         n2=num-1;
  1760.         n1=n2-(nlines-1);
  1761.     }
  1762. /*
  1763. 3
  1764. */
  1765.     ClearBox(x1+1,x2-1,y1+1,y2+2,menu);
  1766.     DoubleBox(xc,xc+xs-1,yc,yc+ys-1,box);
  1767.     WriteStringAtxy(x1,y2+2,xs,highlight,"'Esc'=Quit  'Enter'=Choose file");
  1768.  
  1769.     for(i=0;i<nlines;i++)
  1770.     {
  1771.         WriteStringAtxy(xc+1,yc+i+1,xs-2,menu,string[i+n1]);
  1772.     }
  1773.     WriteStringAtxy(xc+1,yc+1+(n-n1),xs-2,cursor,string[n]);
  1774. /*
  1775. 2
  1776. */
  1777.     i=0;
  1778.     do
  1779.     {
  1780.         ans=getch();
  1781.         if((ans>='a'&&ans<='z')||(ans>='A'&&ans<='Z'))
  1782.         {
  1783.             n=0;
  1784.             i=1;
  1785.             instring[0]=ans;
  1786.             instring[1]='\0';
  1787.             ClearBox(x1,x2,y2+1,y2+1,3);
  1788.             WriteStringAtxy(x1,y2+1,xs,highlight,instring);
  1789.             do
  1790.             {
  1791.                 if(i>0)
  1792.                 {
  1793.                     for(j=n;j<num;j++)
  1794.                     {
  1795.                         if(strnicmp(instring,string[j],i)>=0)
  1796.                         {
  1797.                             n=j;
  1798.                             if(strnicmp(instring,string[j],i)==0)
  1799.                                 break;
  1800.                         }
  1801.                         else
  1802.                             break;
  1803.                     }
  1804.                     n1=n-nlines/2;
  1805.                     if(n1<0)n1=0;
  1806.                     n2=n1+nlines-1;
  1807.                     if(n2>num-1)
  1808.                     {
  1809.                         n2=num-1;
  1810.                         n1=n2-(nlines-1);
  1811.                     }
  1812.                     ClearBox(x1+1,x2-1,y1+1,y2-1,menu);
  1813.                     for(j=0;j<nlines;j++)
  1814.                         WriteStringAtxy(xc+1,yc+j+1,xs-2,menu,string[j+n1]);
  1815.                     WriteStringAtxy(xc+1,yc+1+(n-n1),xs-2,cursor,string[n]);
  1816.                 }
  1817.                 ansc=getch();
  1818.                 if(ansc==0)
  1819.                 {
  1820.                     ansc=getch();
  1821.                     if(ansc!=83&&ans!=82)
  1822.                         ansc=13;
  1823.                 }
  1824.                 if(ansc>31&&ansc<127)
  1825.                 {
  1826.                     instring[i]=ansc;
  1827.                     i+=1;
  1828.                     instring[i]='\0';
  1829.                     ClearBox(x1,x2,y2+1,y2+1,menu);
  1830.                     WriteStringAtxy(x1,y2+1,xs,highlight,instring);
  1831.                 }
  1832.                 if(ansc==8)
  1833.                 {
  1834.                     n=0;
  1835.                     if(i>0)
  1836.                     {
  1837.                         i-=1;
  1838.                         instring[i]='\0';
  1839.                         ClearBox(x1,x2,y2+1,y2+1,menu);
  1840.                         WriteStringAtxy(x1,y2+1,xs,highlight,instring);
  1841.                     }
  1842.                 }
  1843.             }while(ansc!=13&&ansc!=27&&ansc!=83&&ans!=82);
  1844.             if(ansc==27||ansc==83||ansc==82)
  1845.                 ans=ansc;
  1846.             ClearBox(x1,x2,y2+1,y2+1,menu);
  1847.         }
  1848. /*
  1849. 1
  1850. */
  1851.         if(ans==0)
  1852.         {
  1853.             ans=getch();
  1854.             WriteStringAtxy(xc+1,yc+1+(n-n1),xs-2,menu,string[n]);
  1855.             if(ans==80&&n<num-1)        /* 2 */
  1856.                 n+=1; 
  1857.             if(ans==72&&n>0)            /* 8 */
  1858.                 n-=1;
  1859.             if(n>n2)
  1860.             {
  1861.                 n2=n;
  1862.                 n1=n2-(nlines-1);
  1863.                 ScrollUp(1,x1+1,x2-1,y1+1,y2-1,menu);
  1864.             }
  1865.             if(n<n1)
  1866.             {
  1867.                 n1=n;
  1868.                 n2=n1+nlines-1;
  1869.                 ScrollDown(1,x1+1,x2-1,y1+1,y2-1,menu);
  1870.             }
  1871.             if(ans==73)
  1872.             {
  1873.                 if(n1>0&&n==n1)
  1874.                 {
  1875.                     n1-=nlines;
  1876.                     if(n1<0)n1=0;
  1877.                     n2=n1+nlines-1;
  1878.                     n=n1;
  1879.                     ClearBox(x1+1,x2-1,y1+1,y2-1,menu);
  1880.                     for(i=0;i<nlines;i++)
  1881.                         WriteStringAtxy(xc+1,yc+i+1,xs-2,menu,string[i+n1]);
  1882.                 }
  1883.                 else if(n>n1)
  1884.                     n=n1;
  1885.             }
  1886.             if(ans==71)
  1887.             {
  1888.                 if(n1>0)
  1889.                 {
  1890.                     n1=0;
  1891.                     n2=n1+nlines-1;
  1892.                     n=0;
  1893.                     ClearBox(x1+1,x2-1,y1+1,y2-1,menu);
  1894.                     for(i=0;i<nlines;i++)
  1895.                         WriteStringAtxy(xc+1,yc+i+1,xs-2,menu,string[i+n1]);
  1896.                 }
  1897.                 else if(n>0)
  1898.                     n=0;
  1899.             }
  1900.             if(ans==81)
  1901.             {
  1902.                 if(n2<num-1&&n==n2)
  1903.                 {
  1904.                     n2+=nlines;
  1905.                     if(n2>num-1)n2=num-1;
  1906.                     n1=n2-(nlines-1);
  1907.                     n=n2;
  1908.                     ClearBox(x1+1,x2-1,y1+1,y2-1,menu);
  1909.                     for(i=0;i<nlines;i++)
  1910.                         WriteStringAtxy(xc+1,yc+i+1,xs-2,menu,string[i+n1]);
  1911.                 }
  1912.                 else if(n<n2)
  1913.                     n=n2;
  1914.             }
  1915.             if(ans==79)
  1916.             {
  1917.                 if(n2<num-1)
  1918.                 {
  1919.                     n2=num-1;
  1920.                     n1=n2-(nlines-1);
  1921.                     n=n2;
  1922.                     ClearBox(x1+1,x2-1,y1+1,y2-1,menu);
  1923.                     for(i=0;i<nlines;i++)
  1924.                         WriteStringAtxy(xc+1,yc+i+1,xs-2,menu,string[i+n1]);
  1925.                 }
  1926.                 else if(n<n2)
  1927.                     n=num-1;
  1928.             }
  1929.             WriteStringAtxy(xc+1,yc+1+(n-n1),xs-2,cursor,string[n]);
  1930.         }
  1931.     }while(ans!=83&&ans!=27&&ans!=82&&ans!=13);
  1932.     ClearBox(xc,xc+xs-1,yc-1,yc+ys+1,base);
  1933.  
  1934.     if(ans==83||ans==82||ans==13)        /* 'Del or 'Ins' or 'Enter' */
  1935.     {
  1936.         strcpy(out_string,string[n]);
  1937.         return(n);
  1938.     }
  1939.     else                /* 'Esc' */
  1940.     {
  1941.         out_string[0]='\0';
  1942.         return(-1);
  1943.     }
  1944. }
  1945.  
  1946.  
  1947.  
  1948. /**************************************************************************
  1949. **
  1950. **
  1951. **
  1952. ************************************************************************* */
  1953.  
  1954. int histo(xc,yc,xs,ys,bxc,byc,bxs,bys,val,img)
  1955.  
  1956. int xc,yc,xs,ys,bxc,byc,bxs,bys,val,img;
  1957.  
  1958. {
  1959.     int i,j,k,x,y;
  1960.     int ival,csize=15/(FontSize+1),size=FontSize+1;
  1961.     float fval;
  1962.     char string[100];
  1963.     long max=0,del=50000,lk;
  1964.     
  1965.     bys-=30/(FontSize+1)+4;
  1966.     bxs-=45/(FontSize+1);
  1967.     bxc+=45/(FontSize+1);
  1968.     for(k=Hdr[img].data_min;k<=Hdr[img].data_max;k++)
  1969.         Hist[k]=0;
  1970.     for(i=1;i<ys;i++)
  1971.     {
  1972.         getrow(3,xc+1,xc+xs-1,i+yc,Buffer);
  1973.         for(j=0;j<xs-2;j++)
  1974.             Hist[Buffer[j]]+=1;
  1975.     }
  1976.     for(k=Hdr[img].data_min;k<=Hdr[img].data_max;k++)
  1977.         if(Hist[k]>max)
  1978.             max=Hist[k];
  1979.     if(max<150000)del=25000;
  1980.     if(max< 75000)del=12500;
  1981.     if(max< 37500)del= 5000;
  1982.     if(max< 18750)del= 2500;
  1983.     if(max<  9375)del= 2000;
  1984.     if(max<  2344)del=  500;
  1985.     if(max<  1172)del=  200;
  1986.     if(max<   586)del=  100;
  1987.     if(max<   293)del=   50;
  1988.     if(max<   146)del=   25;
  1989.     if(max<    73)del=   10;
  1990.     if(max<    36)del=    5;
  1991.     if(max<    18)del=    2;
  1992.     if(max<     9)del=    1;
  1993.     for(lk=0;lk<max;lk+=del)
  1994.     {
  1995.         fval=lk;
  1996.         fval*=bys;
  1997.         fval/=(float)max;
  1998.         y=fval;
  1999.         plotln(0,bxc-2,byc+bys-y,bxc+2,byc+bys-y,val);
  2000.         sprintf(string,"%3ld",lk);
  2001.         if(y<bys-3)
  2002.             plot_font_h(White,bxc-44/size,
  2003.                     byc+bys-y-12/size,string,size,Font);
  2004.     }
  2005.     for(k=Hdr[img].data_min;k<=Hdr[img].data_max;k+=50)
  2006.     {
  2007.         fval=k;
  2008.         fval*=bxs;
  2009.         fval/=(float)(Hdr[img].data_max-Hdr[img].data_min+1);
  2010.         x=fval;
  2011.         plotln(0,bxc+x,byc+bys,bxc+x,byc+bys+12/size,val);
  2012.         sprintf(string,"%d",k);
  2013.         x-=strlen(string)*csize/2;
  2014.         if(x+strlen(string)*csize>=bxs)
  2015.             x=bxs-1-strlen(string)*csize;
  2016.         plot_font_h(White,bxc+x,byc+bys+4,string,
  2017.             size,Font);
  2018.     }
  2019.     for(k=Hdr[img].data_min;k<=Hdr[img].data_max;k++)
  2020.     {
  2021.         fval=Hist[k];
  2022.         fval*=bys;
  2023.         fval/=(float)max;
  2024.         y=fval;
  2025.         fval=k;
  2026.         fval*=bxs;
  2027.         fval/=(float)(Hdr[img].data_max-Hdr[img].data_min+1);
  2028.         x=fval;
  2029.         plotln(0,bxc+x,byc+bys-y,bxc+x,byc+bys,val);
  2030.     }
  2031. }
  2032.  
  2033.  
  2034.  
  2035. /**************************************************************************
  2036. **
  2037. **
  2038. **
  2039. ************************************************************************* */
  2040.  
  2041. int add_disk_path(string)
  2042.  
  2043. char *string;
  2044.  
  2045. {
  2046.     int i,j,k;
  2047.     char dsk,pth[STR_LEN],nam[10],typ[10],str[STR_LEN];
  2048.     int match,add=0;
  2049.  
  2050.     dsk=fsplit(string,pth,nam,typ);
  2051.     if(dsk>0)
  2052.         sprintf(str,"%c:%s",dsk,pth);
  2053.     else
  2054.         sprintf(str,"%s",pth);
  2055.     if((dsk>0||strlen(pth)>0)&&NumPath<NUM_DP)
  2056.     {
  2057.         match=0;
  2058.         for(i=0;i<NumPath;i++)
  2059.         {
  2060.             if(strcmpi(Path[i],str)==0)
  2061.                 match=1;
  2062.         }
  2063.         if(match==0)
  2064.         {
  2065.             strcpy(Path[NumPath],str);
  2066.             NumPath+=1;
  2067.             add+=1;
  2068.         }
  2069.     }
  2070.     return(add);
  2071. }
  2072.  
  2073.  
  2074.  
  2075. /**************************************************************************
  2076. **
  2077. **
  2078. **
  2079. ************************************************************************* */
  2080.  
  2081. int load_sub_image(filenum)
  2082.  
  2083. int filenum;
  2084.  
  2085. {
  2086.     int i,j,k;
  2087.     int sample=0;
  2088.     int xs,ys;
  2089.     FILE *fp;
  2090.     long offset=0;
  2091.     char string[100];
  2092.     int ret;
  2093.  
  2094.     Row=Hdr[filenum].row;
  2095.     Col=Hdr[filenum].col;
  2096.     if(VideoType=='S')
  2097.         Speed=8;
  2098.  
  2099.     if(Hdr[filenum].sample_bits==0)
  2100.         Hdr[filenum].sample_bits=8;
  2101.  
  2102.     if((Row==0||Col==0)&&Hdr[filenum].row_col_header==0)
  2103.         return(-1);
  2104.     fp=open_to_read_binary(Hdr[filenum].image);
  2105.     if(!fp)
  2106.         return(-1);
  2107.  
  2108.     if(Hdr[filenum].row_col_header==1)
  2109.     {
  2110.         fread((char *)&Hdr[filenum].row,sizeof(int),1,fp);
  2111.         fread((char *)&Hdr[filenum].col,sizeof(int),1,fp);
  2112.         Col=Hdr[filenum].col;
  2113.         Row=Hdr[filenum].row;
  2114.         if(Row<=0||Col<=0)
  2115.             return(-1);
  2116.     }
  2117.     else if(Hdr[filenum].imbedded_header==1)
  2118.     {
  2119.         offset=Hdr[filenum].col;
  2120.         fseek(fp,offset,SEEK_SET);
  2121.     }
  2122.     else if(Hdr[filenum].header_bytes>0)
  2123.     {
  2124.         offset=Hdr[filenum].header_bytes;
  2125.         fseek(fp,offset,SEEK_SET);
  2126.     }
  2127.     do
  2128.     {
  2129.         Sample=sample+=1;
  2130.         Row=Hdr[filenum].row/sample;
  2131.         Col=Hdr[filenum].col/sample;
  2132.         offset=(sample-1);
  2133.         offset*=Hdr[filenum].col;
  2134.     }while(Col>ScreenXs||Row>ScreenYs);
  2135.     ScreenZoom=Hdr[filenum].sample=sample;
  2136.     if(Hdr[filenum].pal_type>0)
  2137.         set_lut(Hdr[filenum].pal_type);
  2138.     else
  2139.     {
  2140.         if(set_lut('P',Hdr[filenum].Lut)<0)
  2141.             set_lut('G');
  2142.     }
  2143.     ret=plot_full_image(fp,sample,filenum);
  2144.     fclose(fp);
  2145.     return(ret);
  2146. }
  2147.  
  2148. /**************************************************************************
  2149. **
  2150. **
  2151. **
  2152. ************************************************************************* */
  2153.  
  2154. int open_image(fp,filenum)
  2155.  
  2156. FILE *fp;
  2157. int filenum;
  2158.  
  2159. {
  2160.     fp=open_to_read_binary(Hdr[filenum].image);
  2161.     if(!fp)
  2162.         return(-1);
  2163.     return(1);
  2164. }
  2165.  
  2166.  
  2167. /**************************************************************************
  2168. **
  2169. **
  2170. **
  2171. ************************************************************************* */
  2172.  
  2173. int split(string,path,name,type)
  2174.  
  2175. char *string,*path,*name,*type;
  2176.  
  2177. {
  2178.     int i,j,k;
  2179.     int dot=-1,last_slash=-1,len=strlen(string),num=0;
  2180.  
  2181.     for(i=0;i<len;i++)
  2182.     {
  2183.         if(string[i]=='.')
  2184.             dot=i;
  2185.         if(string[i]=='\\')
  2186.             last_slash=i;
  2187.     }
  2188.     last_slash+=1;
  2189.     if(dot==-1)
  2190.         dot=len-1;
  2191.     if(last_slash>0)
  2192.     {
  2193.         for(i=0;i<last_slash;i++)
  2194.             path[i]=string[i];
  2195.     }
  2196.     path[last_slash]='\0';
  2197.     for(i=last_slash;i<dot;i++)
  2198.         name[i-last_slash]=string[i];
  2199.     name[dot-last_slash]='\0';
  2200.     dot+=1;
  2201.     for(i=dot;i<len;i++)
  2202.         type[i-dot]=string[i];
  2203.     type[len-dot]='\0';
  2204.     if(strlen(name)>0)
  2205.         num+=1;
  2206.     if(strlen(type)>0)
  2207.         num+=1;
  2208.  
  2209.     return(num);
  2210. }
  2211.  
  2212.  
  2213. /**************************************************************************
  2214. **
  2215. **
  2216. **
  2217. ************************************************************************* */
  2218.  
  2219. int process_image(filenum)
  2220.  
  2221. int filenum;
  2222.  
  2223. {
  2224.     int i,j,k;
  2225.     int num=0;
  2226.     int ix=ScreenXs/2,iy=ScreenYs/2,speed=16/(FontSize-1);
  2227.     FILE *fpout;
  2228.     char string[100],ans,string1[100],string2[100];
  2229.     int val;
  2230.     int xc=0,yc=0,xs,ys,sample=0,scale=1;
  2231.     int bxc,byc,bxs,bys,wxc,wyc,wxs,wys;
  2232.     int npt=Hdr[filenum].data_max-Hdr[filenum].data_min+1;
  2233.     int chigh=24/FontSize,cwide=15/FontSize;
  2234.     int contrast;
  2235.  
  2236.     bxs=          npt/(FontSize-1)+45/(FontSize+1);
  2237.     bxc=ScreenXs-(npt/(FontSize-1)+45/(FontSize+1)+1);
  2238.     bys=          128/(FontSize-1)+30/(FontSize+1)+4;
  2239.     byc=ScreenYs-(128/(FontSize-1)+30/(FontSize+1)+5);
  2240.     wys=wxs=wyc=wxc=ScreenYs/6;
  2241. /*    ZoomSample=1;*/
  2242.     if(load_image(filenum)<0)
  2243.         return(-1);
  2244.     do
  2245.     {
  2246.         num=do_menu_buff(menu_i,MENU_I,MENUXC,25,num,D_Grey,L_Grey,White,Font);
  2247.         if(num==0)
  2248.         {
  2249. /*            ZoomSample=1;*/
  2250.             load_image(filenum);            
  2251.         }
  2252.         if(num==1)
  2253.         {
  2254.             Img=filenum;
  2255.             if(change_color()==0)
  2256.             {
  2257. /*                ZoomSample=1;*/
  2258.                 return(0);
  2259.             }
  2260.         }
  2261.         if(num==2)
  2262.         {
  2263.             pixel_locate(&ix,&iy,&speed,filenum);
  2264.         }
  2265.         if(num==4)
  2266.         {
  2267.             sprintf(string,"Size and Place graph on screen");
  2268.             xc=yc=5;
  2269.             ys=20;xs=(strlen(string)+2)*7;
  2270.             save_sub_mem(xc,yc,xs,ys);
  2271.             paint_box(0,D_Grey,Buffer,xc,yc,xs,ys);
  2272.             plot_font_h(White,xc+7,yc+4,string,2,Font);
  2273.             limit_area_all(&bxc,&byc,&bxs,&bys,&speed,ScreenXs,ScreenYs,
  2274.                 1,Buffer,Black,White,Center);
  2275.             paint_box(0,Black,Buffer,bxc,byc,bxs,bys);
  2276.             box(0,bxc,byc,D_Grey,bxs-1,bys-1);
  2277.             recall_sub_mem(xc,yc,xs,ys);
  2278.             do
  2279.             {
  2280.             if(VideoType=='S')
  2281.                 sprintf(string,"area to process + 'Enter': 'Esc' to exit)");
  2282.             else
  2283.                 sprintf(string,
  2284. "Limit area to process for Histogram  ('Enter' to Process  'Esc' to exit)");
  2285.                 xc=yc=0;
  2286.                 ys=40/FontSize;
  2287.                 xs=(strlen(string)+2)*cwide;
  2288.                 save_sub_mem(xc,yc,xs,ys);
  2289.                 paint_box(0,D_Grey,Buffer,xc,yc,xs,ys);
  2290.                 plot_font_h(White,xc+cwide,yc+1,string,FontSize,Font);
  2291.                 ans=limit_area_all(&wxc,&wyc,&wxs,&wys,&speed,ScreenXs,ScreenYs,
  2292.                     1,Buffer,Black,White,Center);
  2293.                 recall_sub_mem(xc,yc,xs,ys);
  2294.                 if(ans!=27&&wxs>4&&wys>4)
  2295.                 {
  2296.                     paint_box(0,Black,Buffer,bxc,byc,bxs,bys);
  2297.                     box(0,bxc,byc,D_Grey,bxs-1,bys-1);
  2298.                     histo(wxc,wyc,wxs,wys,bxc,byc,bxs,bys,White,filenum);
  2299.                 }
  2300.             }while(ans!=27);            
  2301.             paint_box(0,Black,Buffer,bxc,byc,bxs,bys);
  2302.         }
  2303.         if(num==3)
  2304.         {
  2305.             k=0;
  2306.             do
  2307.             {
  2308.                 if(k>0)
  2309.                     fclose(fpout);
  2310.                 sprintf(string,"imvis%d.tga",k++);
  2311.                 fpout=open_to_read_binary(string);
  2312.             }while(fpout);
  2313.             fclose(fpout);
  2314.             fpout=open_to_write_binary(string);
  2315.             if(!fpout)
  2316.             {
  2317.                 SetVideoMode(0,&B_Id);
  2318.                 printf("Could not open output file.\n\n");
  2319.                 exit(0);
  2320.             }
  2321.             TgaHdr[6]=ScreenXs;
  2322.             TgaHdr[7]=ScreenYs;
  2323.             fwrite((char *)TgaHdr,sizeof(int),9,fpout);
  2324.             for(i=0;i<ScreenYs;i++)
  2325.             {
  2326.                 getrow(0,0,ScreenXs-1,ScreenYs-1-i,Buffer);
  2327.                 for(j=0;j<ScreenXs;j++)
  2328.                 {
  2329.                     val=Buffer[j];
  2330.                     OutBuff[j][0]=Hdr[Img].lut[val].b;
  2331.                     OutBuff[j][1]=Hdr[Img].lut[val].g;
  2332.                     OutBuff[j][2]=Hdr[Img].lut[val].r;
  2333.                 }
  2334.                 fwrite((char *)OutBuff,sizeof(char),ScreenXs*4,fpout);
  2335.             }
  2336.         }
  2337.         if(num==5)
  2338.         {
  2339.             sprintf(string1," Give contrast (1 to 20)");
  2340.             string2[0]='\0';
  2341.             get_string(string,Mbuff,string1,string2,0,0,200,65,1,1,
  2342.                 Font,White);
  2343.             sscanf(string,"%d",&contrast);
  2344.             shade(Img,contrast*Sample/ZoomSample);
  2345.         }
  2346.         if(num==6)
  2347.         {
  2348.             smooth(Img);
  2349.         }
  2350.         if(num==7)
  2351.         {
  2352.             plot_vectors();
  2353.         }
  2354.         if(num==8)
  2355.         {
  2356.             rescale_image();
  2357.         }
  2358.     }while(num<MENU_I-1);
  2359. /*    ZoomSample=1;*/
  2360.     return(1);
  2361. }
  2362.  
  2363. /***********************************************************************
  2364. **
  2365. **
  2366. **
  2367. **
  2368. ************************************************************************/
  2369.  
  2370. int rescale_image()
  2371.  
  2372. {
  2373.     int i,j,k;
  2374.     int speed=8;
  2375.     char ans,string[100];
  2376.     int size=FontSize;
  2377.     
  2378.     Range[0][0]=0;
  2379.     Range[0][1]=127;
  2380.     Range[0][2]=255;
  2381.     scale(0);
  2382.     for(i=0;i<256;i++)
  2383.     {
  2384.         Qlut[i].r=Qlut[i].g=Qlut[i].b=Scale[0][i];
  2385.     }    
  2386.     WritePalette(Qlut);
  2387.     do
  2388.     {
  2389.         ans=getch();
  2390.         if(ans==0)
  2391.         {
  2392.             ans=getch();
  2393.             if(ans==71)Range[0][0]+=speed;
  2394.             if(ans==72)Range[0][1]+=speed;
  2395.             if(ans==73)Range[0][2]+=speed;
  2396.             if(ans==79)Range[0][0]-=speed;
  2397.             if(ans==80)Range[0][1]-=speed;
  2398.             if(ans==81)Range[0][2]-=speed;
  2399.         }
  2400.         else
  2401.         {
  2402.             if(ans=='7')Range[0][0]+=speed;
  2403.             if(ans=='8')Range[0][1]+=speed;
  2404.             if(ans=='9')Range[0][2]+=speed;
  2405.             if(ans=='1')Range[0][0]-=speed;
  2406.             if(ans=='2')Range[0][1]-=speed;
  2407.             if(ans=='3')Range[0][2]-=speed;
  2408.         }
  2409.         if(ans=='+'&&speed<16)
  2410.             speed*=2.0;
  2411.         if(ans=='-'&&speed>1)
  2412.             speed/=2.0;
  2413.         for(k=0;k<3;k++)
  2414.         {
  2415.             if(Range[0][k]<0)
  2416.                 Range[0][k]=0;
  2417.             if(Range[0][k]>255)
  2418.                 Range[0][k]=255;
  2419.         }
  2420.         if(Range[0][1]<Range[0][0])Range[0][1]=Range[0][0];
  2421.         if(Range[0][2]<Range[0][1])Range[0][2]=Range[0][1];
  2422.         paint_box(0,D_Grey,Buffer,0,ScreenYs-30/size,ScreenXs,30/size);
  2423.         sprintf(string,"%3d  %3d  %3d",Range[0][0],Range[0][1],Range[0][2]);
  2424.         plot_font_h(White,2,ScreenYs-30/size+2,string,size,Font);
  2425.         scale(0);
  2426.         for(i=0;i<256;i++)
  2427.         {
  2428.             Qlut[i].r=Qlut[i].g=Qlut[i].b=Scale[0][i];
  2429.         }    
  2430.         WritePalette(Qlut);
  2431.     }while(ans!=13);
  2432. }
  2433.  
  2434.  
  2435.  
  2436.  
  2437. /***********************************************************************
  2438. **
  2439. **
  2440. **
  2441. **
  2442. ************************************************************************/
  2443.  
  2444. int smooth(img)
  2445.  
  2446. int img;
  2447.  
  2448. {
  2449.     int i,j,k,m,n;
  2450.     unsigned char *buffer[4];
  2451.     int sum,num;
  2452.     int n1=Hdr[img].data_min,n2=Hdr[img].data_max;
  2453.  
  2454.     for(i=0;i<4;i++)
  2455.         buffer[i]=Ibuff+ScreenXs*i;
  2456.     for(i=0;i<2;i++)
  2457.         getrow(0,0,ScreenXs-1,i,buffer[i%3]);
  2458.     for(i=1;i<ScreenYs-1;i++)
  2459.     {
  2460.         getrow(0,0,ScreenXs-1,i+1,buffer[(i+1)%3]);
  2461.         for(j=1;j<ScreenXs-1;j++)
  2462.         {
  2463.             buffer[3][j]=buffer[i%3][j];
  2464.             if(buffer[i%3][j]>=n1&&buffer[i%3][j]<=n2)
  2465.             {
  2466.                 sum=num=0;
  2467.                 for(m=-1;m<=1;m++)
  2468.                 {
  2469.                     for(n=-1;n<=1;n++)
  2470.                     {
  2471.                         if(buffer[(i+m)%3][j+n]>=n1&&buffer[(i+m)%3][j+n]<=n2)
  2472.                         {
  2473.                             sum+=buffer[(i+m)%3][j+n];
  2474.                             num+=1;
  2475.                         }
  2476.                     }
  2477.                 }
  2478.                 if(num>1)
  2479.                     buffer[3][j]=sum/num;
  2480.             }
  2481.         }
  2482.         plotrow(0,1,ScreenXs-2,i,buffer[3]+1);
  2483.     }
  2484. }
  2485.  
  2486.  
  2487.  
  2488.  
  2489. /***********************************************************************
  2490. **
  2491. **
  2492. **
  2493. **
  2494. ************************************************************************/
  2495.  
  2496. int shade(img,scale)
  2497.  
  2498. int img,scale;
  2499.  
  2500. {
  2501.     int i,j,k;
  2502.     int j1,j2;
  2503.     int n1=Hdr[img].data_min,n2=Hdr[img].data_max,num=n2-n1;
  2504.     int val,val1,val2,mid=n1+num/2;
  2505.  
  2506.     for(i=0;i<256;i++)
  2507.     {
  2508.         Hdr[img].lutc[i].r=Hdr[img].lut[i].r;
  2509.         Hdr[img].lutc[i].g=Hdr[img].lut[i].g;
  2510.         Hdr[img].lutc[i].b=Hdr[img].lut[i].b;
  2511.     }
  2512.     for(i=n1;i<=n2;i++)
  2513.     {
  2514.         val=i-n1;
  2515.         val*=255;
  2516.         val/=num;
  2517.         Hdr[img].lutc[i].r=Hdr[img].lutc[i].g=Hdr[img].lutc[i].b=val;
  2518.     }
  2519.     WritePalette(Hdr[Img].lutc);
  2520.     for(i=0;i<ScreenYs;i++)
  2521.     {
  2522.         getrow(0,0,ScreenXs-1,i,Buffer);
  2523.         for(j=0;j<ScreenXs;j++)
  2524.         {
  2525.             val1=Buffer[j];
  2526.             if(val1<n1||val1>n2)
  2527.                 val1=0;
  2528.             val2=Buffer[j+1];
  2529.             if(val2<n1||val2>n2)
  2530.                 val2=0;
  2531.             val=val2-val1;
  2532.             val*=scale;
  2533.             val+=mid;
  2534.             if(val<n1)
  2535.                 val=n1;
  2536.             if(val>n2)
  2537.                 val=n2;
  2538.             Buffer[j]=val;
  2539.         }
  2540.         plotrow(0,0,ScreenXs-1,i,Buffer);
  2541.     }
  2542. }
  2543.  
  2544.  
  2545. /********************************************************************
  2546. **
  2547. **
  2548. **
  2549. ********************************************************************* */
  2550.  
  2551. int plot_vectors()
  2552.  
  2553. {
  2554.     int i,j,k,m,n;
  2555.     double fSam,fsam,rsam;
  2556.     double a0,a1,b0,b1;
  2557.     char string[STR_LEN];
  2558.     int val,numsec,numpt;
  2559.     float mll[4],latlon[2];
  2560.     double x,y,lat,lon,lat1,lat2;
  2561.     int ix,iy,ixo,iyo,sx,sy;
  2562.     float pixsize;
  2563.     FILE *fp;
  2564.     int num=0;
  2565.     int nsample=-1,zscale=1;
  2566.  
  2567.  
  2568.     if(ScreenZoom>0)
  2569.     {
  2570.         fSam=(double)Sample;
  2571.         fsam=(double)ScreenZoom;
  2572.         rsam=fSam/fsam;
  2573.         a0=-rsam*(double)Xc;
  2574.         a1=1.0/fsam;
  2575.         b0=-rsam*(double)Yc;
  2576.         b1=1.0/fsam;
  2577.     }
  2578.     else
  2579.     {
  2580.         nsample=ScreenZoom*-1+2;
  2581.         zscale=1;
  2582.         fSam=(double)Sample;
  2583.         fsam=(double)nsample;
  2584.         rsam=fSam*fsam;
  2585.         a0=-rsam*(double)Xc;
  2586.         a1=fsam;
  2587.         b0=-rsam*(double)Yc;
  2588.         b1=fsam;
  2589.     }
  2590.  
  2591.     sx=ScreenXs/2;
  2592.     sy=ScreenYs/2;
  2593.     if(ScreenZoom>0)
  2594.     {
  2595.         ix=Xc*Sample+sx*ScreenZoom;
  2596.         iy=Yc*Sample+sy*ScreenZoom;
  2597.     }
  2598.     else
  2599.     {
  2600.         ix=Xc*Sample+sx*nsample;
  2601.         iy=Yc*Sample+sy*nsample;
  2602.     }
  2603.     if(Vector<=0)
  2604.         return(0);
  2605.     lat1=clat((double)ix,(double)iy);
  2606.     sy-=1;
  2607.     if(ScreenZoom>0)
  2608.         iy=Yc*Sample+sy*ScreenZoom;
  2609.     else
  2610.         iy-=1;
  2611.     lat2=clat((double)ix,(double)iy);
  2612.     pixsize=(lat2-lat1)*R*PI*2.0/360.0;
  2613.     if(ScreenZoom<1)
  2614.         pixsize/=(float)nsample;
  2615.     for(i=0;i<Vector;i++)
  2616.         menu_l[i]=Group_Name[i];
  2617.     menu_l[Vector]="exit vector plot";
  2618.     do
  2619.     {
  2620.         num=do_menu_buff(menu_l,Vector+1,MENUXC,25,num,D_Grey,L_Grey,White,Font);
  2621.         i=num;
  2622.         if(i<Vector)
  2623.         {
  2624.             for(j=0;j<Ns[i];j++)
  2625.             {
  2626.                 if(pixsize<MapFile[i][j].max_pix&&pixsize>=MapFile[i][j].min_pix)
  2627.                 {
  2628.                     strcpy(string,MapFile[i][j].filename);
  2629.                     strcat(string,".bin");
  2630.                     fp=open_to_read_binary(string);
  2631.                     if(fp)
  2632.                     {
  2633.                         val=MapFile[i][j].color;
  2634.                         fread((char *)&numsec,sizeof(int),1,fp);
  2635.                         for(k=0;k<numsec;k++)
  2636.                         {
  2637.                             if(kbhit()>0)
  2638.                             {
  2639.                                 val=getch();
  2640.                                 if(val==27)
  2641.                                     return(-2);
  2642.                             }
  2643.                             fread((char *)&numpt,sizeof(int),1,fp);
  2644.                             fread((char *)mll,sizeof(float),4,fp);
  2645.                             for(m=0;m<numpt;m++)
  2646.                             {
  2647.                                 fread((char *)latlon,sizeof(float),2,fp);
  2648.                                 lat=latlon[0];
  2649.                                 lon=latlon[1];
  2650.                                 x=cx(lat,lon);
  2651.                                 y=cy(lat,lon);
  2652.                                 ix=a0+a1*x;
  2653.                                 iy=b0+b1*y;
  2654.                                 if(m>0)
  2655.                                 {
  2656.                                     if((ix <ScreenXs&&ix >=0&&iy <ScreenYs&&iy >=0)||
  2657.                                         (ixo<ScreenXs&&ixo>=0&&iyo<ScreenYs&&iyo>=0))
  2658.                                         plotln(0,ix,iy,ixo,iyo,val);
  2659.                                 }
  2660.                                 ixo=ix;
  2661.                                 iyo=iy;
  2662.                             }
  2663.                         }
  2664.                     }
  2665.                 }
  2666.             }
  2667.         }
  2668.     }while(num<Vector);
  2669. }
  2670.  
  2671. /********************************************************************
  2672. **
  2673. **
  2674. **
  2675. ********************************************************************* */
  2676.  
  2677. int graph_locate(x,y,speed)
  2678.  
  2679. int *x,*y,*speed;
  2680.  
  2681. {
  2682.     char ans,ans2,string[100];
  2683.     unsigned char buffer[100],buff[640];
  2684.     int csize=6,xo=*x,yo=*y,ix,iy,val;
  2685.     float fx,fx0,fx1,fx2,delx,fy,fy0,fy1,fy2,dely;
  2686.     int x1,x2,y1,y2;
  2687.     int cval,ccolor,cx=ScreenXs/2,cy=ScreenYs/2;
  2688.  
  2689.     get_string(string,Mbuff,"Give x and y value of a point",
  2690.         "then move cursor and enter",
  2691.         10,10,30*15/FontSize,95/FontSize,1,1,
  2692.         Font,L_Grey);
  2693.     sscanf(string,"%f%f",&fx1,&fy1);
  2694.     get_xy(cx,cy,speed,ix,iy);
  2695.     x1=cx;
  2696.     y1=cy;
  2697.     get_string(string,Mbuff,"Give x and y value of 2nd point",
  2698.         "then move cursor and enter",
  2699.         10,10,30*15/FontSize,95/FontSize,1,1,
  2700.         Font,L_Grey);
  2701.     sscanf(string,"%f%f",&fx2,&fy2);
  2702.     get_xy(cx,cy,speed,ix,iy);
  2703.     x2=cx;
  2704.     y2=cy;
  2705.     if(x1==x1&&y1==y2)
  2706.         return(-1);
  2707.     if(x2!=x1)
  2708.         delx=(fx2-fx1)/((float)x2-(float)x1);
  2709.     else
  2710.         delx=0.0;
  2711.     if(y2!=y1)
  2712.         dely=(fy2-fy1)/((float)y2-(float)y1);
  2713.     else
  2714.         dely=0;
  2715.     
  2716.     cval=getpt(0,*x,*y);
  2717.     if(((int)Hdr[Img].lut[cval].r*10+
  2718.             (int)Hdr[Img].lut[cval].g*8+(int)Hdr[Img].lut[cval].b*2)>2048)
  2719.         ccolor=Black;
  2720.     else
  2721.         ccolor=White;
  2722.     tcursor(0,*x,*y,csize,buffer);
  2723.     cursor(0,*x,*y,ccolor,csize);
  2724.     paint_box(0,Black,buff,0,ScreenYs-35,121,35);
  2725.     sprintf(string,"x=%3d y=%3d",*x,*y);
  2726.     plot_font_h(White,2,ScreenYs-33,string,2,Font);
  2727.     do
  2728.     {
  2729.         ans=getch();
  2730.         if(ans=='-'&&*speed>1)
  2731.             *speed/=2;
  2732.         if(ans=='+'&&*speed<ScreenYs/2)
  2733.             *speed*=2;
  2734.         if(ans==0)
  2735.         {
  2736.             ans2=getch();
  2737.             if(ans2==71||ans2==75||ans2==79)
  2738.                 *x-=*speed;
  2739.             if(ans2==73||ans2==77||ans2==81)
  2740.                 *x+=*speed;
  2741.             if(ans2==71||ans2==72||ans2==73)
  2742.                 *y-=*speed;
  2743.             if(ans2==79||ans2==80||ans2==81)
  2744.                 *y+=*speed;
  2745.             if(*x<0)
  2746.                 *x=0;
  2747.             if(*x>=ScreenXs)
  2748.                 *x=ScreenXs-1;
  2749.             if(*y<0)
  2750.                 *y=0;
  2751.             if(*y>=ScreenYs)
  2752.                 *y=ScreenYs-1;
  2753.             uncursor(0,xo,yo,csize,buffer);
  2754.             cval=getpt(0,*x,*y);
  2755.             if(((int)Hdr[Img].lut[cval].r*10+
  2756.                     (int)Hdr[Img].lut[cval].g*8+(int)Hdr[Img].lut[cval].b*2)>2048)
  2757.                 ccolor=Black;
  2758.             else
  2759.                 ccolor=White;
  2760.             tcursor(0,*x,*y,csize,buffer);
  2761.             cursor(0,*x,*y,ccolor,csize);
  2762.             paint_box(0,Black,buff,0,ScreenYs-35,221,35);
  2763.             val=getpt(0,*x,*y);
  2764.             fx=(float)(*x-x1)*delx;
  2765.             fy=(float)(*y-x1)*dely;
  2766.             sprintf(string,"x=%3d y=%3d fx=%0.5f fy=%0.5f",*x,*y,val,fx,fy);
  2767.             plot_font_h(White,2,ScreenYs-33,string,2,Font);
  2768.             ix=Xc*Sample+*x*ZoomSample;
  2769.             iy=Yc*Sample+*y*ZoomSample;
  2770.             sprintf(string,"%5d %5d",ix,iy);
  2771.             plot_font_h(White,2,ScreenYs-16,string,2,Font);
  2772.             xo=*x;
  2773.             yo=*y;
  2774.         }
  2775.     }while(ans!=27&&ans!=13);
  2776.     uncursor(0,xo,yo,csize,buffer);
  2777.     paint_box(0,Black,buff,0,ScreenYs-33,121,30);
  2778. }
  2779.  
  2780. /***********************************************************************
  2781. **
  2782. **
  2783. **
  2784. **
  2785. ************************************************************************/
  2786.  
  2787. int get_xy(x,y,speed,imgx,imgy)
  2788.  
  2789. int *x,*y,*speed,*imgx,*imgy;
  2790.  
  2791. {
  2792.     char ans,ans2;
  2793.     int cval,ccolor,csize=6;
  2794.     int ix,iy,xo,yo;
  2795.  
  2796.     do
  2797.     {
  2798.         ans=getch();
  2799.         if(ans=='-'&&*speed>1)
  2800.             *speed/=2;
  2801.         if(ans=='+'&&*speed<ScreenYs/2)
  2802.             *speed*=2;
  2803.         if(ans==0)
  2804.         {
  2805.             ans2=getch();
  2806.             if(ans2==71||ans2==75||ans2==79)
  2807.                 *x-=*speed;
  2808.             if(ans2==73||ans2==77||ans2==81)
  2809.                 *x+=*speed;
  2810.             if(ans2==71||ans2==72||ans2==73)
  2811.                 *y-=*speed;
  2812.             if(ans2==79||ans2==80||ans2==81)
  2813.                 *y+=*speed;
  2814.             if(*x<0)
  2815.                 *x=0;
  2816.             if(*x>=ScreenXs)
  2817.                 *x=ScreenXs-1;
  2818.             if(*y<0)
  2819.                 *y=0;
  2820.             if(*y>=ScreenYs)
  2821.                 *y=ScreenYs-1;
  2822.             uncursor(0,xo,yo,csize,Buffer);
  2823.             cval=getpt(0,*x,*y);
  2824.             if(((int)Hdr[Img].lut[cval].r*10+
  2825.                     (int)Hdr[Img].lut[cval].g*8+(int)Hdr[Img].lut[cval].b*2)>2048)
  2826.                 ccolor=Black;
  2827.             else
  2828.                 ccolor=White;
  2829.             tcursor(0,*x,*y,csize,Buffer);
  2830.             cursor(0,*x,*y,ccolor,csize);
  2831.             ix=Xc*Sample+*x*ZoomSample;
  2832.             iy=Yc*Sample+*y*ZoomSample;
  2833.             xo=*x;
  2834.             yo=*y;
  2835.         }
  2836.     }while(ans!=27&&ans!=13);
  2837.     uncursor(0,xo,yo,csize,Buffer);
  2838.     *imgx=ix;
  2839.     *imgy=iy;
  2840. }
  2841.  
  2842. /********************************************************************
  2843. **
  2844. **
  2845. **
  2846. ********************************************************************* */
  2847.  
  2848. int video_off()
  2849.  
  2850. {
  2851.     SetVideoMode(0,&B_Id);
  2852. }
  2853.  
  2854. /********************************************************************
  2855. **
  2856. **
  2857. **
  2858. ********************************************************************* */
  2859.  
  2860. int pixel_locate(x,y,speed,img)
  2861.  
  2862. int *x,*y,*speed;
  2863.  
  2864. {
  2865.     char ans,ans2,string[100],string2[100];
  2866.     unsigned char buffer[100],buff[640];
  2867.     int csize=6,xo=*x,yo=*y,ix,iy,val;
  2868.     int cval,ccolor;
  2869.     unsigned char r,g,b;
  2870.     long offset,lx,ly,row=Hdr[img].row,col=Hdr[img].col;
  2871.     FILE *fpr,*fpg,*fpb;
  2872.  
  2873.     if(ChannelOn==1)    /* RGB channel file names available */
  2874.     {
  2875.         fpr=fopen(Channel[0],"rb");
  2876.         fpg=fopen(Channel[1],"rb");
  2877.         fpb=fopen(Channel[2],"rb");
  2878.         if(!fpr||!fpg||!fpb)
  2879.             ChannelOn=0;        /* at least one file missing */
  2880.     }
  2881.     cval=getpt(0,*x,*y);
  2882.     if(((int)Hdr[Img].lut[cval].r*10+
  2883.             (int)Hdr[Img].lut[cval].g*8+(int)Hdr[Img].lut[cval].b*2)>2048)
  2884.         ccolor=Black;
  2885.     else
  2886.         ccolor=White;
  2887.     tcursor(0,*x,*y,csize,buffer);
  2888.     cursor(0,*x,*y,ccolor,csize);
  2889.     paint_box(0,Black,buff,0,ScreenYs-35,ScreenXs,35);
  2890.     sprintf(string,"x=%3d y=%3d",*x,*y);
  2891.     plot_font_h(White,2,ScreenYs-33,string,2,Font);
  2892.     do
  2893.     {
  2894.         ans=getch();
  2895.         if(ans=='-'&&*speed>1)
  2896.             *speed/=2;
  2897.         if(ans=='+'&&*speed<ScreenYs/2)
  2898.             *speed*=2;
  2899.         if(ans==0)
  2900.         {
  2901.             ans2=getch();
  2902.             if(ans2==71||ans2==75||ans2==79)
  2903.                 *x-=*speed;
  2904.             if(ans2==73||ans2==77||ans2==81)
  2905.                 *x+=*speed;
  2906.             if(ans2==71||ans2==72||ans2==73)
  2907.                 *y-=*speed;
  2908.             if(ans2==79||ans2==80||ans2==81)
  2909.                 *y+=*speed;
  2910.             if(*x<0)
  2911.                 *x=0;
  2912.             if(*x>=ScreenXs)
  2913.                 *x=ScreenXs-1;
  2914.             if(*y<0)
  2915.                 *y=0;
  2916.             if(*y>=ScreenYs)
  2917.                 *y=ScreenYs-1;
  2918.             uncursor(0,xo,yo,csize,buffer);
  2919.             cval=getpt(0,*x,*y);
  2920.             if(((int)Hdr[Img].lut[cval].r*10+
  2921.                 (int)Hdr[Img].lut[cval].g*8+(int)Hdr[Img].lut[cval].b*2)>2048)
  2922.                 ccolor=Black;
  2923.             else
  2924.                 ccolor=White;
  2925.             tcursor(0,*x,*y,csize,buffer);
  2926.             cursor(0,*x,*y,ccolor,csize);
  2927.             paint_box(0,Black,buff,0,ScreenYs-35,ScreenXs,35);
  2928.             val=getpt(0,*x,*y);
  2929.             lx=ix=Xc*Sample+*x*ZoomSample;
  2930.             ly=iy=Yc*Sample+*y*ZoomSample;
  2931.             lx*=Sample_Rate;
  2932.             ly*=Sample_Rate;
  2933.             if(ChannelOn==1&&ix<col&&iy<row)
  2934.             {
  2935.                 offset=ly*col*Sample_Rate+lx;
  2936.                 fseek(fpr,offset,SEEK_SET);
  2937.                 fseek(fpg,offset,SEEK_SET);
  2938.                 fseek(fpb,offset,SEEK_SET);
  2939.                 if(fread((char *)&r,sizeof(char),1,fpr)<1)
  2940.                 {
  2941.                     SetVideoMode(0,&B_Id);
  2942.                     printf("could not read '%s'\n",Channel[0]);
  2943.                     exit(0);
  2944.                 }
  2945.                 if(fread((char *)&g,sizeof(char),1,fpg)<1)
  2946.                 {
  2947.                     SetVideoMode(0,&B_Id);
  2948.                     printf("could not read '%s'\n",Channel[1]);
  2949.                     exit(0);
  2950.                 }
  2951.                 if(fread((char *)&b,sizeof(char),1,fpb)<1)
  2952.                 {
  2953.                     SetVideoMode(0,&B_Id);
  2954.                     printf("could not read '%s'\n",Channel[2]);
  2955.                     exit(0);
  2956.                 }
  2957.             }
  2958.             sprintf(string,"x=%3d y=%3d %3d",*x,*y,val);
  2959.             if(ChannelOn==1&&ix<col&&iy<row)
  2960.             {
  2961.                 sprintf(string2,"  r:%3d g:%3d b:%3d",r,g,b);
  2962.                 strcat(string,string2);
  2963.             }    
  2964.             plot_font_h(White,2,ScreenYs-33,string,2,Font);
  2965.             if(Nav.numlat>0)
  2966.                 sprintf(string,"%5d %5d lat = %9.5lf lon = %10.5lf",
  2967.                     ix,iy,clat((double)ix,(double)iy),clon((double)ix,(double)iy));
  2968.             else
  2969.                 sprintf(string,"%5d %5d",ix,iy);
  2970.             plot_font_h(White,2,ScreenYs-16,string,2,Font);
  2971.             xo=*x;
  2972.             yo=*y;
  2973.         }
  2974.     }while(ans!=27&&ans!=13);
  2975.     uncursor(0,xo,yo,csize,buffer);
  2976.     paint_box(0,Black,buff,0,ScreenYs-33,121,30);
  2977.     fclose(fpr);
  2978.     fclose(fpg);
  2979.     fclose(fpb);
  2980. }
  2981.  
  2982. /**************************************************************************
  2983. **
  2984. **
  2985. **
  2986. ************************************************************************* */
  2987.  
  2988. double clat(x,y)
  2989.  
  2990. double x,y;
  2991.  
  2992. {
  2993.     double lat=Nav.B_Lat[0];
  2994.  
  2995.     if(Nav.numlat>1)
  2996.         lat+=Nav.B_Lat[1]*y;
  2997.     if(Nav.numlat>2)
  2998.         lat+=Nav.B_Lat[2]*y*y;
  2999.     if(Nav.numlat>3)
  3000.         lat+=Nav.B_Lat[3]*x;
  3001.     if(Nav.numlat>4)
  3002.         lat+=Nav.B_Lat[4]*x*x;
  3003.     if(Nav.numlat>5)
  3004.         lat+=Nav.B_Lat[5]*y*x;
  3005.     return(lat);
  3006. }
  3007.  
  3008. /**************************************************************************
  3009. **
  3010. **
  3011. **
  3012. ************************************************************************* */
  3013.  
  3014. double clon(x,y)
  3015.  
  3016. double x,y;
  3017.  
  3018. {
  3019.     double lon=Nav.B_Lon[0];
  3020.  
  3021.     if(Nav.numlon>1)
  3022.         lon+=Nav.B_Lon[1]*x;
  3023.     if(Nav.numlon>2)
  3024.         lon+=Nav.B_Lon[2]*x*x;
  3025.     if(Nav.numlon>3)
  3026.         lon+=Nav.B_Lon[3]*y;
  3027.     if(Nav.numlon>4)
  3028.         lon+=Nav.B_Lon[4]*y*y;
  3029.     if(Nav.numlon>5)
  3030.         lon+=Nav.B_Lon[5]*y*x;
  3031.     return(lon);
  3032. }
  3033.  
  3034. /**************************************************************************
  3035. **
  3036. **
  3037. **
  3038. ************************************************************************* */
  3039.  
  3040. double cy(lat,lon)
  3041.  
  3042. double lat,lon;
  3043.  
  3044. {
  3045.     double y=Nav.B_Y[0];
  3046.  
  3047.     if(Nav.numy>1)
  3048.         y+=Nav.B_Y[1]*lat;
  3049.     if(Nav.numy>2)
  3050.         y+=Nav.B_Y[2]*lat*lat;
  3051.     if(Nav.numy>3)
  3052.         y+=Nav.B_Y[3]*lon;
  3053.     if(Nav.numy>4)
  3054.         y+=Nav.B_Y[4]*lon*lon;
  3055.     if(Nav.numy>5)
  3056.         y+=Nav.B_Y[5]*lat*lon;
  3057.     return(y);
  3058. }
  3059.  
  3060. /**************************************************************************
  3061. **
  3062. **
  3063. **
  3064. ************************************************************************* */
  3065.  
  3066. double cx(lat,lon)
  3067.  
  3068. double lat,lon;
  3069.  
  3070. {
  3071.     double x=Nav.B_X[0];
  3072.  
  3073.     if(Nav.numx>1)
  3074.         x+=Nav.B_X[1]*lon;
  3075.     if(Nav.numx>2)
  3076.         x+=Nav.B_X[2]*lon*lon;
  3077.     if(Nav.numx>3)
  3078.         x+=Nav.B_X[3]*lat;
  3079.     if(Nav.numx>4)
  3080.         x+=Nav.B_X[4]*lat*lat;
  3081.     if(Nav.numx>5)
  3082.         x+=Nav.B_X[5]*lat*lon;
  3083.     return(x);
  3084. }
  3085.  
  3086.  
  3087. /**************************************************************************
  3088. **
  3089. **
  3090. **
  3091. ************************************************************************* */
  3092.  
  3093. int change_color()
  3094.  
  3095. {
  3096.     int i,j,k;
  3097.     int num=0;
  3098.     int maxr=-1,maxg=-1,maxb=-1,minr=256,ming=256,minb=256;
  3099.     float flut[3],flutm[3],fdel[3],fmin[3],fv[3],fr[3];
  3100.     float scale=1.0,dels=0.05,max,min,tint[3],brite=1.0;
  3101.     FILE *fplut;
  3102.     int val;
  3103.     char ans,ans2;
  3104.  
  3105.     /* put lut into lutc for safe keeping */
  3106.     for(i=0;i<256;i++)
  3107.     {
  3108.         Hdr[Img].lutc[i].r=Hdr[Img].lut[i].r;
  3109.         Hdr[Img].lutc[i].g=Hdr[Img].lut[i].g;
  3110.         Hdr[Img].lutc[i].b=Hdr[Img].lut[i].b;
  3111.     }
  3112.     do
  3113.     {
  3114.         num=do_menu_buff(menu_c,MENU_C,MENUXC,25,num,D_Grey,L_Grey,White,Font);
  3115.         if(num==0)  /* change saturation and tint and brightness*/
  3116.         {
  3117.             for(k=0;k<3;k++)
  3118.                 tint[k]=1.0;
  3119.             brite=scale=1.0;
  3120.             while((ans=getch())!=27&&ans!=13)
  3121.             {
  3122.                 if(ans==0)
  3123.                 {
  3124.                     ans2=getch();
  3125.                     if(ans2==71)tint[0]+=dels;
  3126.                     if(ans2==72)tint[1]+=dels;
  3127.                     if(ans2==73)tint[2]+=dels;
  3128.                     if(ans2==79)tint[0]-=dels;
  3129.                     if(ans2==80)tint[1]-=dels;
  3130.                     if(ans2==81)tint[2]-=dels;
  3131.                     for(k=0;k<3;k++)
  3132.                     {
  3133.                         if(tint[k]<0.0)tint[k]=0.0;
  3134.                         if(tint[k]>1.0)tint[k]=1.0;
  3135.                     }
  3136.                 }
  3137.                 if(ans=='+')
  3138.                     scale+=dels;
  3139.                 if(ans=='-')
  3140.                     scale-=dels;
  3141.                 if(scale<0.0)
  3142.                     scale=0.0;
  3143.                 if(scale> 2.0)
  3144.                     scale= 2.0;
  3145.                 if(ans=='b')
  3146.                     brite+=dels;
  3147.                 if(ans=='d')
  3148.                     brite-=dels;
  3149.                 if(brite<0.0)
  3150.                     brite=0.0;
  3151.                 if(ans=='r')
  3152.                 {
  3153.                     for(i=0;i<256;i++)        /* put original (c) into lut */
  3154.                     {
  3155.                         Hdr[Img].lut[i].r=Hdr[Img].lutc[i].r;
  3156.                         Hdr[Img].lut[i].g=Hdr[Img].lutc[i].g;
  3157.                         Hdr[Img].lut[i].b=Hdr[Img].lutc[i].b;
  3158.                     }
  3159.                     scale=1.0;
  3160.                     for(k=0;k<3;k++)
  3161.                         tint[k]=1.0;
  3162.                 }
  3163.                 for(i=0;i<256;i++)
  3164.                 {
  3165.                     fv[0]=Hdr[Img].lut[i].r;
  3166.                     fv[1]=Hdr[Img].lut[i].g;
  3167.                     fv[2]=Hdr[Img].lut[i].b;
  3168.                     max=0.0;min=256.0;
  3169.                     for(k=0;k<3;k++)
  3170.                     {
  3171.                         if(fv[k]>max)max=fv[k];
  3172.                         if(fv[k]<min)min=fv[k];
  3173.                     }
  3174.                     if(max>min)
  3175.                     {
  3176.                         for(k=0;k<3;k++)
  3177.                             fr[k]=(fv[k]-min)/(max-min);
  3178.                         if(scale>1.0)
  3179.                             min*=2.0-scale;
  3180.                         else
  3181.                             min+=(max-min)*(1.0-scale);
  3182.                         for(k=0;k<3;k++)
  3183.                         {
  3184.                             fv[k]=fr[k]*(max-min)+min+0.5;
  3185.                             if(fv[k]<0.0)fv[k]=0.0;
  3186.                             if(fv[k]>256.0)fv[k]=256.0;
  3187.                         }
  3188.                     }
  3189.                     for(k=0;k<3;k++)
  3190.                     {
  3191.                         fv[k]*=brite*tint[k];
  3192.                         if(fv[k]>255.0)
  3193.                             fv[k]=255.0;
  3194.                     }
  3195.                     Hdr[Img].lutm[i].r=fv[0];
  3196.                     Hdr[Img].lutm[i].g=fv[1];
  3197.                     Hdr[Img].lutm[i].b=fv[2];
  3198.                 }
  3199.                 WritePalette(Hdr[Img].lutm);
  3200.             }
  3201.             for(i=0;i<256;i++)        /* put changed palette (m) into lut */
  3202.             {
  3203.                 Hdr[Img].lut[i].r=Hdr[Img].lutm[i].r;
  3204.                 Hdr[Img].lut[i].g=Hdr[Img].lutm[i].g;
  3205.                 Hdr[Img].lut[i].b=Hdr[Img].lutm[i].b;
  3206.             }
  3207.         }
  3208.         if(num==1)  /* stretch table */
  3209.         {
  3210.             maxr=-1;
  3211.             maxg=-1;
  3212.             maxb=-1;
  3213.             minr=256;
  3214.             ming=256;
  3215.             minb=256;
  3216.             for(i=0;i<256;i++)
  3217.             {
  3218.                 if((Hdr[Img].lut[i].r<255||Hdr[Img].lut[i].g<255||
  3219.                         Hdr[Img].lut[i].b<255)&&
  3220.                     (Hdr[Img].lut[i].r>0||Hdr[Img].lut[i].g>0||Hdr[Img].lut[i].b>0))
  3221.                 {
  3222.                     if((int)Hdr[Img].lut[i].r>maxr)maxr=Hdr[Img].lut[i].r;
  3223.                     if((int)Hdr[Img].lut[i].r<minr)minr=Hdr[Img].lut[i].r;
  3224.                     if((int)Hdr[Img].lut[i].g>maxg)maxg=Hdr[Img].lut[i].g;
  3225.                     if((int)Hdr[Img].lut[i].g<ming)ming=Hdr[Img].lut[i].g;
  3226.                     if((int)Hdr[Img].lut[i].b>maxb)maxb=Hdr[Img].lut[i].b;
  3227.                     if((int)Hdr[Img].lut[i].b<minb)minb=Hdr[Img].lut[i].b;
  3228.                 }
  3229.             }
  3230.             fdel[0]=maxr-minr;
  3231.             fdel[1]=maxg-ming;
  3232.             fdel[2]=maxb-minb;
  3233.             fmin[0]=minr;
  3234.             fmin[1]=ming;
  3235.             fmin[2]=minb;
  3236.             for(i=0;i<256;i++)
  3237.             {
  3238.                 flut[0]=Hdr[Img].lut[i].r;
  3239.                 flut[1]=Hdr[Img].lut[i].g;
  3240.                 flut[2]=Hdr[Img].lut[i].b;
  3241.                 for(k=0;k<3;k++)
  3242.                 {
  3243.                     val=(flut[k]-fmin[k])/fdel[k]*255.0;
  3244.                     if(val<0.0)
  3245.                         val=0.0;
  3246.                     if(val>255.0)
  3247.                         val=255.0;
  3248.                     flutm[k]=val;
  3249.                 }
  3250.                 Hdr[Img].lut[i].r=flutm[0];
  3251.                 Hdr[Img].lut[i].g=flutm[1];
  3252.                 Hdr[Img].lut[i].b=flutm[2];
  3253.             }
  3254.             WritePalette(Hdr[Img].lut);
  3255.         }
  3256.         if(num==2)        /* reset */
  3257.         {
  3258.             for(i=0;i<256;i++)        /* put original (c) into lut */
  3259.             {
  3260.                 Hdr[Img].lut[i].r=Hdr[Img].lutc[i].r;
  3261.                 Hdr[Img].lut[i].g=Hdr[Img].lutc[i].g;
  3262.                 Hdr[Img].lut[i].b=Hdr[Img].lutc[i].b;
  3263.             }
  3264.             scale=1.0;
  3265.             for(k=0;k<3;k++)
  3266.                 tint[k]=1.0;
  3267.             WritePalette(Hdr[Img].lut);
  3268.         }
  3269.         if(num==MENU_C-2&&VideoType!='V')
  3270.         {
  3271.             SetVideoMode(0,&B_Id);
  3272.             printf(
  3273. "\n\nYou have requested that the Look Up Table be changed.  If you proceed\n");
  3274.             printf(
  3275. "you will replace the current '.pal' file with a new one and the current\n");
  3276.             printf(
  3277. "file will be destroyed.  You may wish to make a copy of it first.\n\n");
  3278.             printf("        Do you wish to continue?  (y or n)\n\n");
  3279.             if(getch()=='y')
  3280.             {
  3281.                 if(strlen(Hdr[Img].Lut)>0)
  3282.                 {
  3283.                     fplut=open_to_write_text(Hdr[Img].Lut);
  3284.                     if(fplut)
  3285.                     {
  3286.                         for(i=0;i<Num_Color;i++)
  3287.                             fprintf(fplut,"%3d %3d %3d %3d\n",i,
  3288.                                 Hdr[Img].lut[i].r,
  3289.                                 Hdr[Img].lut[i].g,
  3290.                                 Hdr[Img].lut[i].b);
  3291.                         fclose(fplut);
  3292.                     }
  3293.                 }
  3294.             }
  3295.             video_on();
  3296.             WritePalette(Hdr[Img].lut);
  3297.             return(0);
  3298.         }
  3299.     }while(num<MENU_C-1);
  3300.     return(1);
  3301. }
  3302.  
  3303.  
  3304.  
  3305. /**************************************************************************
  3306. **
  3307. **
  3308. **
  3309. ************************************************************************* */
  3310.  
  3311. int load_image(filenum)
  3312.  
  3313. int filenum;
  3314.  
  3315. {
  3316.     int i,j,k;
  3317.     int sample=0;
  3318.     int xs,ys;
  3319.     FILE *fp;
  3320.     long offset=0;
  3321.     char string[100];
  3322.  
  3323.     Row=Hdr[filenum].row;
  3324.     Col=Hdr[filenum].col;
  3325.     if(VideoType=='S')
  3326.         Speed=8;
  3327.  
  3328.     if(Hdr[filenum].sample_bits==0)
  3329.         Hdr[filenum].sample_bits=8;
  3330.  
  3331.     if((Row==0||Col==0)&&Hdr[filenum].row_col_header==0)
  3332.         return(-1);
  3333.     fp=open_to_read_binary(Hdr[filenum].image);
  3334.     if(!fp)
  3335.         return(-1);
  3336.     if(Hdr[filenum].row_col_header==1)
  3337.     {
  3338.         fread((char *)&Hdr[filenum].row,sizeof(int),1,fp);
  3339.         fread((char *)&Hdr[filenum].col,sizeof(int),1,fp);
  3340.         Col=Hdr[filenum].col;
  3341.         Row=Hdr[filenum].row;
  3342.         if(Row<=0||Col<=0)
  3343.             return(-1);
  3344.     }
  3345.     else if(Hdr[filenum].imbedded_header==1)
  3346.     {
  3347.         offset=Hdr[filenum].col;
  3348.         fseek(fp,offset,SEEK_SET);
  3349.     }
  3350.     else if(Hdr[filenum].header_bytes>0)
  3351.     {
  3352.         offset=Hdr[filenum].header_bytes;
  3353.         fseek(fp,offset,SEEK_SET);
  3354.     }
  3355.     video_on();
  3356.     set_lut('G');
  3357.     do
  3358.     {
  3359.         Sample=sample+=1;
  3360.         Row=Hdr[filenum].row/sample;
  3361.         Col=Hdr[filenum].col/sample;
  3362.         offset=(sample-1);
  3363.         offset*=Hdr[filenum].col;
  3364.     }while(Col>ScreenXs||Row>ScreenYs);
  3365.     Hdr[filenum].sample=sample;
  3366.     if(Hdr[filenum].pal_type>0)
  3367.         set_lut(Hdr[filenum].pal_type);
  3368.     else
  3369.     {
  3370.         if(set_lut('P',Hdr[filenum].Lut)<0)
  3371.             set_lut('G');
  3372.     }
  3373.     plot_full_image(fp,sample,filenum);
  3374.  
  3375.     if(sample>-17)
  3376.     {
  3377.         sample=ZoomSample;
  3378.         if(limit_area_fixed(&Xc,&Yc,&xs,&ys,&Speed,&sample)!=27)
  3379.         {
  3380.             ZoomSample=sample;
  3381.             plot_sub_image(fp,sample,filenum);
  3382.         }
  3383.         else
  3384.         {
  3385.             ZoomSample=Sample;
  3386.             return(0);
  3387.         }
  3388.     }
  3389.     fclose(fp);
  3390.     return(1);
  3391. }
  3392.  
  3393. /**************************************************************************
  3394. **
  3395. **
  3396. **
  3397. ************************************************************************* */
  3398.  
  3399. int plot_sub_image(fp,sample,filenum)
  3400.  
  3401. FILE *fp;
  3402. int sample,filenum;
  3403.  
  3404. {
  3405.     int i,j,k;
  3406.     long offset;
  3407.     int val,nsample=sample*-1+2,zscale=1;
  3408.  
  3409.     ScreenZoom=sample;
  3410.     if(sample<1)
  3411.         zscale=nsample;
  3412.     rewind(fp);
  3413.     offset=Hdr[filenum].col;
  3414.     offset*=Yc*Sample;
  3415.     offset+=Xc*Sample;
  3416.     if(Hdr[filenum].header_bytes>0)
  3417.         offset+=Hdr[filenum].header_bytes;
  3418.     fseek(fp,offset,SEEK_SET);
  3419.     Row=ScreenYs;
  3420.     Col=ScreenXs;
  3421.     offset=Hdr[filenum].col;
  3422.     if(sample>0)
  3423.     {
  3424.         if((Yc*Sample+Row*sample)>Hdr[filenum].row)
  3425.             Row=(Hdr[filenum].row-Yc*Sample)/sample;
  3426.         if((Xc*Sample+Col*sample)>Hdr[filenum].col)
  3427.             Col=(Hdr[filenum].col-Xc*Sample)/sample;
  3428.     }
  3429.     else
  3430.     {
  3431.         if((Yc*Sample+Row/nsample)>Hdr[filenum].row)
  3432.             Row=(Hdr[filenum].row-Yc*Sample)*nsample;
  3433.         if((Xc*Sample+Col/nsample)>Hdr[filenum].col)
  3434.             Col=(Hdr[filenum].col-Xc*Sample)*nsample;
  3435.         offset=0;
  3436.     }
  3437.     offset*=(sample-1);
  3438.     for(i=0;i<Row/zscale;i++)
  3439.     {
  3440.         if(fread((char *)Mbuff,sizeof(char),Hdr[filenum].col,fp)<1)
  3441.             return(-1);
  3442.         if(kbhit()>0)
  3443.         {
  3444.             val=getch();
  3445.             if(val==27)
  3446.                 return(-2);
  3447.         }
  3448.         if(offset>0)
  3449.             fseek(fp,offset,SEEK_CUR);
  3450.         if(sample>1)
  3451.             for(j=0;j<Col;j++)
  3452.                 Mbuff[j]=Mbuff[j*sample];
  3453.         if(sample<1)
  3454.             for(j=Col-1;j>0;j--)
  3455.                 Mbuff[j]=Mbuff[j/nsample];
  3456.         if(VideoType=='V'||VideoType=='E')
  3457.         {
  3458.             if(ActiveLut=='P')
  3459.             {
  3460.                 for(j=0;j<Col;j++)
  3461.                     Mbuff[j]=Hdr[filenum].vga_color[Mbuff[j]];
  3462.             }
  3463.             else
  3464.             {
  3465.                 for(j=0;j<Col;j++)
  3466.                     Mbuff[j]/=16;
  3467.             }
  3468.         }
  3469.         if(sample>0)
  3470.             plotrow(3,0,Col-1,i,Mbuff);
  3471.         else
  3472.             for(k=0;k<nsample;k++)
  3473.                 plotrow(3,0,Col-1,i*nsample+k,Mbuff);
  3474.     }
  3475.     return(1);
  3476. }
  3477.  
  3478.  
  3479. /**************************************************************************
  3480. **
  3481. **
  3482. **
  3483. ************************************************************************* */
  3484.  
  3485. int plot_full_image(fp,sample,filenum)
  3486.  
  3487. FILE *fp;
  3488. int sample,filenum;
  3489.  
  3490. {
  3491.     int i,j,k;
  3492.     long offset;
  3493.     char string[100];
  3494.     int row,col,val;
  3495.     FILE *fpsub;
  3496.  
  3497.     strcpy(string,Hdr[filenum].image);
  3498.     for(i=0;i<strlen(string);i++)
  3499.         if(string[i]=='.')
  3500.             string[i]='\0';
  3501.     strcat(string,SubType);
  3502.     fpsub=open_to_read_binary(string);
  3503.     if(fpsub)
  3504.     {
  3505.         fread((char *)&row,sizeof(int),1,fpsub);
  3506.         fread((char *)&col,sizeof(int),1,fpsub);
  3507.         for(i=0;i<row;i++)
  3508.         {
  3509.             fread((char *)Mbuff,sizeof(char),col,fpsub);
  3510.             if(kbhit()>0)
  3511.             {
  3512.                 val=getch();
  3513.                 if(val==27)
  3514.                     return(-2);
  3515.             }
  3516.             plotrow(0,0,col-1,i,Mbuff);
  3517.         }
  3518.         fclose(fpsub);
  3519.     }
  3520.     else
  3521.     {
  3522.         if(!fp)
  3523.         {
  3524.             SetVideoMode(0,&B_Id);
  3525.             printf("In plot_full_image() fp = (null)\n");
  3526.             exit(0);
  3527.         }
  3528.         rewind(fp);
  3529.         offset=Hdr[filenum].header_bytes;
  3530.         if(offset>0)
  3531.             fseek(fp,offset,SEEK_SET);
  3532.         offset=(sample-1);
  3533.         offset*=Hdr[filenum].col;
  3534.         for(i=0;i<Row;i++)
  3535.         {
  3536.             fread((char *)Mbuff,sizeof(char),Hdr[filenum].col,fp);
  3537.             if(kbhit()>0)
  3538.             {
  3539.                 val=getch();
  3540.                 if(val==27)
  3541.                     return(-2);
  3542.             }
  3543.             if(offset>0)
  3544.                 fseek(fp,offset,SEEK_CUR);
  3545.             if(sample>1)
  3546.                 for(j=0;j<Col;j++)
  3547.                     Mbuff[j]=Mbuff[j*sample];
  3548.             if(VideoType=='V'||VideoType=='E')
  3549.             {
  3550.                 if(ActiveLut=='P')
  3551.                 {
  3552.                     for(j=0;j<Col;j++)
  3553.                         Mbuff[j]=Hdr[filenum].vga_color[Mbuff[j]];
  3554.                 }
  3555.                 else
  3556.                 {
  3557.                     for(j=0;j<Col;j++)
  3558.                         Mbuff[j]/=16;
  3559.                 }
  3560.             }
  3561.             plotrow(3,0,Col-1,i,Mbuff);
  3562.         }
  3563.         if(sample>1)
  3564.         {
  3565.             fpsub=open_to_write_binary(string);
  3566.             if(fpsub)
  3567.             {
  3568.                 fwrite((char *)&Row,sizeof(int),1,fpsub);
  3569.                 fwrite((char *)&Col,sizeof(int),1,fpsub);
  3570.                 for(i=0;i<Row;i++)
  3571.                 {
  3572.                     getrow(0,0,Col-1,i,Mbuff);
  3573.                     fwrite((char *)Mbuff,sizeof(char),Col,fpsub);
  3574.                 }
  3575.                 fclose(fpsub);
  3576.             }
  3577.         }
  3578.     }
  3579. }
  3580.  
  3581. /**************************************************************************
  3582. **
  3583. **
  3584. **
  3585. ************************************************************************* */
  3586.  
  3587. int limit_area_fixed(xc,yc,xs,ys,speed,sample)
  3588.  
  3589. int *xc,*yc,*xs,*ys,*speed,*sample;
  3590.  
  3591. {
  3592.     int i,j,k;
  3593.     int xco=*xc,yco=*yc,xso,yso;
  3594.     char ans;
  3595.  
  3596.     if(*sample>0)
  3597.     {
  3598.         xso=*xs=ScreenXs/Sample*(*sample);
  3599.         yso=*ys=ScreenYs/Sample*(*sample);
  3600.     }
  3601.     else
  3602.     {
  3603.         xso=*xs=ScreenXs/Sample/(*sample*-1+2);
  3604.         yso=*ys=ScreenYs/Sample/(*sample*-1+2);
  3605.     }
  3606.     if(*sample>0)
  3607.         tbox_val(3,*xc,*yc,*xs,*ys,Mbuff,Black,White,Center);
  3608.     else
  3609.         tbox_val(3,*xc,*yc,*xs,*ys,Mbuff,White,Black,Center);
  3610.     do
  3611.     {
  3612.         ans=getch();
  3613.         unbox(3,*xc,*yc,*xs,*ys,Mbuff);
  3614.         if(ans==27)
  3615.         {
  3616.             return(27);
  3617.         }
  3618.         else if(ans=='-'&&*speed>1)*speed/=2;
  3619.         else if(ans=='+'&&*speed<ScreenYs)*speed*=2;
  3620.         else if(ans=='l'&&*sample<Sample)
  3621.             *sample+=1;
  3622.         else if(ans=='s')
  3623.             *sample-=1;
  3624.         if(*sample>0)
  3625.         {
  3626.             *xs=ScreenXs/Sample*(*sample);
  3627.             *ys=ScreenYs/Sample*(*sample);
  3628.         }
  3629.         else
  3630.         {
  3631.             *xs=ScreenXs/Sample/(*sample*-1+2);
  3632.             *ys=ScreenYs/Sample/(*sample*-1+2);
  3633.         }
  3634.         if(ans==0)
  3635.         {
  3636.             ans=getch();
  3637.             if(ans==71)
  3638.             {
  3639.                 *xc-=*speed;
  3640.                 *yc-=*speed;
  3641.             }
  3642.             else if(ans==73)
  3643.             {
  3644.                 *xc+=*speed;
  3645.                 *yc-=*speed;
  3646.             }
  3647.             else if(ans==79)
  3648.             {
  3649.                 *xc-=*speed;
  3650.                 *yc+=*speed;
  3651.             }
  3652.             else if(ans==81)
  3653.             {
  3654.                 *xc+=*speed;
  3655.                 *yc+=*speed;
  3656.             }
  3657.             else if(ans==72)
  3658.                 *yc-=*speed;
  3659.             else if(ans==80)
  3660.                 *yc+=*speed;
  3661.             else if(ans==75)
  3662.                 *xc-=*speed;
  3663.             else if(ans==77)
  3664.                 *xc+=*speed;
  3665.         }
  3666.         if(*xs>ScreenXs)*xs=ScreenXs;
  3667.         if(*ys>ScreenYs)*ys=ScreenYs;
  3668.         if(*xs<2)*xs=2;
  3669.         if(*ys<2)*ys=2;
  3670.         if((*xc+*xs)>=ScreenXs)*xc=ScreenXs-*xs;
  3671.         if((*yc+*ys)>=ScreenYs)*yc=ScreenYs-*ys;
  3672.         if(*xc<0)*xc=0;
  3673.         if(*yc<0)*yc=0;
  3674.         if(*sample>0)
  3675.             tbox_val(3,*xc,*yc,*xs,*ys,Mbuff,Black,White,Center);
  3676.         else
  3677.             tbox_val(3,*xc,*yc,*xs,*ys,Mbuff,White,Black,Center);
  3678.     }while(ans!=83&&ans!='x'&&ans!=27&&ans!=13);
  3679.     unbox(3,*xc,*yc,*xs,*ys,Mbuff);
  3680.     return(ans);
  3681. }
  3682.  
  3683. /**************************************************************************
  3684. **
  3685. **
  3686. **
  3687. ************************************************************************* */
  3688.  
  3689. int read_lbl(label,filenum)
  3690.  
  3691. char *label;
  3692. int filenum;
  3693.  
  3694. {
  3695.     int i,j,k;
  3696.     char string1[100],string2[100],string3[100],string[100];
  3697.     FILE *fp;
  3698.     int status=1,numread,n1,n2,n3,num;
  3699.  
  3700.     fp=open_to_read_text(label);    
  3701.     if(!fp)
  3702.         return(-1);
  3703.     Hdr[filenum].sample_bits=Hdr[filenum].record_bytes=0;
  3704.     Hdr[filenum].file_records=0;
  3705.     Hdr[filenum].pal_type=0;
  3706.     Hdr[filenum].row_col_header=0;
  3707.  
  3708.     Hdr[filenum].infile[0]='\0';
  3709.     Hdr[filenum].image[0]='\0';
  3710.     Hdr[filenum].Lut[0]='\0';
  3711.     Hdr[filenum].label[0]='\0';
  3712.  
  3713.     for(i=0;i<NUM_IMAGE;i++)
  3714.         Reverse[i]=0;
  3715.     Nav.numlat=Nav.numlon=0;
  3716.     Nav.numy  =Nav.numy  =0;
  3717.     Hdr[filenum].data_min=0;
  3718.     Hdr[filenum].data_max=255;
  3719.     Sample_Rate=1;
  3720.     ChannelOn=Vector=0;
  3721.     while(fscanf(fp,"%s",string1)==1)
  3722.     {
  3723.         if(strcmpi(string1,"end")==0)
  3724.         {
  3725.             fclose(fp);
  3726.             return(status);
  3727.         }
  3728.         if(strcmpi(string1,"image_lines")==0&&Hdr[filenum].file_records==0)
  3729.         {
  3730.             numread=fscanf(fp,"%s%s",string2,string3);
  3731.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3732.                 numread<2)
  3733.             {
  3734.                 fclose(fp);
  3735.                 return(status);
  3736.             }            
  3737.             sscanf(string3,"%d",&Hdr[filenum].row);
  3738.         }
  3739.         if(strcmpi(string1,"sample_bits")==0)
  3740.         {
  3741.             numread=fscanf(fp,"%s%s",string2,string3);
  3742.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3743.                 numread<2)
  3744.             {
  3745.                 fclose(fp);
  3746.                 return(status);
  3747.             }            
  3748.             sscanf(string3,"%d",&Hdr[filenum].sample_bits);
  3749.         }
  3750.         if(strcmpi(string1,"CHANNEL_INPUT:")==0)
  3751.         {
  3752.             ChannelOn=1;
  3753.             while(fgetc(fp)!=0xa);    /* skip to end of line */
  3754.             for(k=0;k<3;k++)
  3755.             {
  3756.                 if(!fgets(string1,99,fp))
  3757.                 {
  3758.                     printf("Invalid CHANNEL_INPUT:\n");
  3759.                     exit(0);
  3760.                 }
  3761.                 sscanf(string1+13,"%s",Channel[k]);
  3762.             }
  3763.         }
  3764.         if(strcmpi(string1,"SAMPLE_RATE")==0)
  3765.         {
  3766.             numread=fscanf(fp,"%s%s",string2,string3);
  3767.             sscanf(string3,"%ld",&Sample_Rate);
  3768.             if(Sample_Rate<1||Sample_Rate>30)
  3769.             {
  3770.                 printf("Invalid SAMPLE_RATE = %ld\n",Sample_Rate);
  3771.                 exit(0);
  3772.             }
  3773.         }
  3774.         if(strcmpi(string1,"file_records")==0)
  3775.         {
  3776.             numread=fscanf(fp,"%s%s",string2,string3);
  3777.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3778.                 numread<2)
  3779.             {
  3780.                 fclose(fp);
  3781.                 return(status);
  3782.             }            
  3783.             sscanf(string3,"%d",&Hdr[filenum].row);
  3784.             Hdr[filenum].file_records=Hdr[filenum].row;
  3785.         }
  3786.         if(strcmpi(string1,"line_samples")==0&&Hdr[filenum].record_bytes==0)
  3787.         {
  3788.             numread=fscanf(fp,"%s%s",string2,string3);
  3789.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3790.                 numread<2)
  3791.             {
  3792.                 fclose(fp);
  3793.                 return(status);
  3794.             }            
  3795.             sscanf(string3,"%d",&Hdr[filenum].col);
  3796.         }
  3797.         if(strcmpi(string1,"record_bytes")==0||
  3798.             strcmpi(string1,"image_record_bytes")==0)
  3799.         {
  3800.             numread=fscanf(fp,"%s%s",string2,string3);
  3801.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3802.                 numread<2)
  3803.             {
  3804.                 fclose(fp);
  3805.                 return(status);
  3806.             }            
  3807.             sscanf(string3,"%d",&Hdr[filenum].col);
  3808.             Hdr[filenum].record_bytes=Hdr[filenum].col;
  3809.         }
  3810.         if(strcmpi(string1,"header_bytes")==0)
  3811.         {
  3812.             numread=fscanf(fp,"%s%s",string2,string3);
  3813.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3814.                 numread<2)
  3815.             {
  3816.                 fclose(fp);
  3817.                 return(status);
  3818.             }            
  3819.             sscanf(string3,"%d",&Hdr[filenum].header_bytes);
  3820.         }
  3821.         if(strcmpi(string1,"data_max")==0)
  3822.         {
  3823.             numread=fscanf(fp,"%s%s",string2,string3);
  3824.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3825.                 numread<2)
  3826.             {
  3827.                 fclose(fp);
  3828.                 return(status);
  3829.             }            
  3830.             sscanf(string3,"%d",&Hdr[filenum].data_max);
  3831.         }
  3832.         if(strcmpi(string1,"data_min")==0)
  3833.         {
  3834.             numread=fscanf(fp,"%s%s",string2,string3);
  3835.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3836.                 numread<2)
  3837.             {
  3838.                 fclose(fp);
  3839.                 return(status);
  3840.             }            
  3841.             sscanf(string3,"%d",&Hdr[filenum].data_min);
  3842.         }
  3843.         if(strcmpi(string1,"image_pointer")==0)
  3844.         {
  3845.             numread=fscanf(fp,"%s%s",string2,string3);
  3846.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3847.                 numread<2)
  3848.             {
  3849.                 fclose(fp);
  3850.                 return(status);
  3851.             }            
  3852.             k=0;
  3853.             for(i=0;i<strlen(string3);i++)
  3854.                 if(string3[i]!=39)        /* single quote */
  3855.                     Hdr[filenum].image[k++]=string3[i];
  3856.             Hdr[filenum].image[k]='\0';
  3857.         }
  3858.         if(strcmpi(string1,"pal_type")==0)
  3859.         {
  3860.             numread=fscanf(fp,"%s%s",string2,string3);
  3861.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3862.                 numread<2)
  3863.             {
  3864.                 fclose(fp);
  3865.                 return(status);
  3866.             }            
  3867.             k=0;
  3868.             for(i=0;i<strlen(string3);i++)
  3869.                 if(string3[i]!=39)        /* single quote */
  3870.                     string1[k++]=string3[i];
  3871.             string1[k]='\0';
  3872.             Hdr[filenum].pal_type=string1[0];
  3873.         }
  3874.         if(strcmpi(string1,"pal_pointer")==0)
  3875.         {
  3876.             numread=fscanf(fp,"%s%s",string2,string3);
  3877.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3878.                 numread<2)
  3879.             {
  3880.                 fclose(fp);
  3881.                 return(status);
  3882.             }            
  3883.             k=0;
  3884.             for(i=0;i<strlen(string3);i++)
  3885.                 if(string3[i]!=39)        /* single quote */
  3886.                     Hdr[filenum].Lut[k++]=string3[i];
  3887.             Hdr[filenum].Lut[k]='\0';
  3888.         }
  3889.         if(strcmpi(string1,"row_col_header")==0)
  3890.         {
  3891.             numread=fscanf(fp,"%s%s",string2,string3);
  3892.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3893.                 numread<2)
  3894.             {
  3895.                 fclose(fp);
  3896.                 return(status);
  3897.             }            
  3898.             Hdr[filenum].row_col_header=1;
  3899.             Hdr[filenum].header_bytes=4;
  3900.         }
  3901.         if(strcmpi(string1,"latitude_coef")==0)
  3902.         {
  3903.             numread=fscanf(fp,"%s%s",string2,string3);
  3904.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3905.                 numread<2)
  3906.             {
  3907.                 fclose(fp);
  3908.                 return(status);
  3909.             }            
  3910.             sscanf(string3,"%d",&Nav.numlat);
  3911.             if(Nav.numlat>MAX_LL||Nav.numlat<2)
  3912.             {
  3913.                 printf("Invalid number of Latitude coefficients '%s'\n\n",string3);
  3914.                 exit(0);
  3915.             }
  3916.             for(i=0;i<Nav.numlat;i++)
  3917.             {
  3918.                 fscanf(fp,"%s",string3);
  3919.                 if(sscanf(string3,"%lf",Nav.B_Lat+i)<1)
  3920.                 {
  3921.                     printf("Invalid latitude '%s'\n\n",string3);
  3922.                     exit(0);
  3923.                 }
  3924.             }
  3925.         }
  3926.         if(strcmpi(string1,"y_coef")==0)
  3927.         {
  3928.             numread=fscanf(fp,"%s%s",string2,string3);
  3929.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3930.                 numread<2)
  3931.             {
  3932.                 fclose(fp);
  3933.                 return(status);
  3934.             }            
  3935.             sscanf(string3,"%d",&Nav.numy);
  3936.             if(Nav.numy>MAX_LL||Nav.numy<2)
  3937.             {
  3938.                 printf("Invalid number of Y coefficients '%s'\n\n",string3);
  3939.                 exit(0);
  3940.             }
  3941.             for(i=0;i<Nav.numy;i++)
  3942.             {
  3943.                 fscanf(fp,"%s",string3);
  3944.                 if(sscanf(string3,"%lf",Nav.B_Y+i)<1)
  3945.                 {
  3946.                     printf("Invalid Y coef. '%s'\n\n",string3);
  3947.                     exit(0);
  3948.                 }
  3949.             }
  3950.         }
  3951.         if(strcmpi(string1,"longitude_coef")==0)
  3952.         {
  3953.             numread=fscanf(fp,"%s%s",string2,string3);
  3954.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3955.                 numread<2)
  3956.             {
  3957.                 fclose(fp);
  3958.                 return(status);
  3959.             }            
  3960.             sscanf(string3,"%d",&Nav.numlon);
  3961.             if(Nav.numlon>MAX_LL||Nav.numlon<2)
  3962.             {
  3963.                 printf("Invalid number of longitude coefficients '%s'\n\n",string3);
  3964.                 exit(0);
  3965.             }
  3966.             for(i=0;i<Nav.numlon;i++)
  3967.             {
  3968.                 fscanf(fp,"%s",string3);
  3969.                 if(sscanf(string3,"%lf",Nav.B_Lon+i)<1)
  3970.                 {
  3971.                     printf("Invalid longitude '%s'\n\n",string3);
  3972.                     exit(0);
  3973.                 }
  3974.             }
  3975.         }
  3976.         if(strcmpi(string1,"x_coef")==0)
  3977.         {
  3978.             numread=fscanf(fp,"%s%s",string2,string3);
  3979.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  3980.                 numread<2)
  3981.             {
  3982.                 fclose(fp);
  3983.                 return(status);
  3984.             }            
  3985.             sscanf(string3,"%d",&Nav.numx);
  3986.             if(Nav.numx>MAX_LL||Nav.numx<2)
  3987.             {
  3988.                 printf("Invalid number of X coefficients '%s'\n\n",string3);
  3989.                 exit(0);
  3990.             }
  3991.             for(i=0;i<Nav.numx;i++)
  3992.             {
  3993.                 fscanf(fp,"%s",string3);
  3994.                 if(sscanf(string3,"%lf",Nav.B_X+i)<1)
  3995.                 {
  3996.                     printf("Invalid X coef. '%s'\n\n",string3);
  3997.                     exit(0);
  3998.                 }
  3999.             }
  4000.         }
  4001.         if(strcmpi(string1,"set_pointer")==0||strcmpi(string1,"set_pointers")==0)
  4002.         {
  4003.             numread=fscanf(fp,"%s%s",string2,string3);
  4004.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  4005.                 numread<2)
  4006.             {
  4007.                 printf("invalid 'set_pointer' format\n\n");
  4008.                 exit(0);
  4009.             }
  4010.             sscanf(string3,"%d",&Num_Active_Image);
  4011.             if(Num_Active_Image>=NUM_IMAGE)
  4012.             {
  4013.                 printf("Invalid number of images in set.\n\n");
  4014.                 exit(0);
  4015.             }
  4016.             for(i=0;i<Num_Active_Image;i++)
  4017.             {
  4018.                 Range[i][0]=0;
  4019.                 Range[i][1]=127;
  4020.                 Range[i][2]=255;
  4021.             }
  4022.             for(i=0;i<Num_Active_Image;i++)
  4023.             {
  4024.                 if(!fgets(string,99,fp))
  4025.                 {
  4026.                     printf("Error reading 'set_pointer'\n");
  4027.                     exit(0);
  4028.                 }
  4029.                 num=sscanf(string,"%s%d%d%d",string1,&n1,&n2,&n3);
  4030.                 if(num<1||strlen(string)==0)
  4031.                 {
  4032.                     fgets(string,99,fp);
  4033.                     num=sscanf(string,"%s%d%d%d",string1,&n1,&n2,&n3);
  4034.                 }
  4035.                 if(num==4)
  4036.                 {
  4037.                     Range[i][0]=n1;
  4038.                     Range[i][1]=n2;
  4039.                     Range[i][2]=n3;
  4040.                 }
  4041.                 if(num==3)
  4042.                 {
  4043.                     Range[i][0]=n1;
  4044.                     Range[i][2]=n2;
  4045.                     Range[i][1]=(Range[i][0]+Range[i][1])/2;
  4046.                 }
  4047.                 copy_hdr(i,0);
  4048.                 strcpy(Hdr[i].image,string1);
  4049.             }
  4050.             return(Num_Active_Image);
  4051.         }
  4052.         if(strcmpi(string1,"vector_sets")==0)
  4053.         {
  4054.             numread=fscanf(fp,"%s%s",string2,string3);
  4055.             if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  4056.                 numread<2)
  4057.             {
  4058.                 printf("invalid 'vector_sets' format\n\n");
  4059.                 exit(0);
  4060.             }
  4061.             sscanf(string3,"%d",&Vector);
  4062.             if(Vector<1||Vector>=NUM_TYPE)
  4063.             {
  4064.                 printf("Invalid number of vector sets.\n");
  4065.                 exit(0);
  4066.             }
  4067.             for(i=0;i<Vector;i++)
  4068.             {
  4069.                 numread=fscanf(fp,"%s%s%s",Group_Name[i],string2,string3);
  4070.                 if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
  4071.                     numread<2)
  4072.                 {
  4073.                     printf("invalid 'vector_set' format at set %d\n\n",i+1);
  4074.                     exit(0);
  4075.                 }
  4076.                 sscanf(string3,"%d",Ns+i);
  4077.                 if(Ns[i]<1||Ns[i]>=NUM_SIZE)
  4078.                 {
  4079.                     printf("Invalid number of vectors.\n");
  4080.                     exit(0);
  4081.                 }
  4082.                 for(j=0;j<Ns[i];j++)
  4083.                 {
  4084.                     numread=fscanf(fp,"%s%f%f%d",
  4085.                         MapFile[i][j].filename,&MapFile[i][j].max_pix,
  4086.                         &MapFile[i][j].min_pix,&MapFile[i][j].color);
  4087.                     if(numread<4)
  4088.                     {
  4089.                         printf("invalid 'vector' format at set i=%d j=%d\n\n",
  4090.                             i+1,j+1);
  4091.                         exit(0);
  4092.                     }
  4093.                 }
  4094.             }
  4095.         }
  4096.     }
  4097.     fclose(fp);
  4098.     return(status);
  4099. }
  4100.  
  4101.  
  4102. /***********************************************************************
  4103. **
  4104. **
  4105. **
  4106. **
  4107. ************************************************************************/
  4108.  
  4109. int copy_hdr(d,s)
  4110.  
  4111. int d,s;  /* (d)estination and (s)ource */
  4112.  
  4113. {
  4114.     int i,j,k;
  4115.  
  4116.     Hdr[d].row=Hdr[s].row;
  4117.     Hdr[d].col=Hdr[s].col;
  4118.     Hdr[d].sample=Hdr[s].sample;
  4119.     Hdr[d].record_bytes=Hdr[s].record_bytes;
  4120.     Hdr[d].file_records=Hdr[s].file_records;
  4121.     Hdr[d].record_col_header=Hdr[s].record_col_header;
  4122.     Hdr[d].row_col_header=Hdr[s].row_col_header;
  4123.     Hdr[d].header_bytes=Hdr[s].header_bytes;
  4124.     Hdr[d].imbedded_header=Hdr[s].imbedded_header;
  4125.     Hdr[d].sample_bits=Hdr[s].sample_bits;
  4126.     Hdr[d].pal_type=Hdr[s].pal_type;
  4127.  
  4128.     strcpy(Hdr[d].infile,Hdr[s].infile);
  4129.     strcpy(Hdr[d].image,Hdr[s].image);
  4130.     strcpy(Hdr[d].Lut,Hdr[s].Lut);
  4131.     strcpy(Hdr[d].label,Hdr[s].label);
  4132.  
  4133.     for(i=0;i<256;i++)
  4134.     {
  4135.         Hdr[d].vga_color[i]=Hdr[s].vga_color[i];
  4136.  
  4137.         Hdr[d].lut[i].r=Hdr[s].lut[i].r;
  4138.         Hdr[d].lut[i].g=Hdr[s].lut[i].g;
  4139.         Hdr[d].lut[i].b=Hdr[s].lut[i].b;
  4140.         Hdr[d].lutm[i].r=Hdr[s].lutm[i].r;
  4141.         Hdr[d].lutm[i].g=Hdr[s].lutm[i].g;
  4142.         Hdr[d].lutm[i].b=Hdr[s].lutm[i].b;
  4143.         Hdr[d].lutc[i].r=Hdr[s].lutc[i].r;
  4144.         Hdr[d].lutc[i].g=Hdr[s].lutc[i].g;
  4145.         Hdr[d].lutc[i].b=Hdr[s].lutc[i].b;
  4146.     }
  4147. }
  4148.  
  4149. /********************************************************************
  4150. **
  4151. **    type  g -- grey all lut[] files
  4152. **            G -- grey only lut[]
  4153. **            i -- initial header map
  4154. **            r -- reset lut[] to lutc[]
  4155. **            p -- positive (0-127) magenta, negative (128-255) green
  4156. **
  4157. ********************************************************************* */
  4158.  
  4159. int set_lut(type,filename)
  4160.  
  4161. char type,*filename;
  4162.  
  4163. {
  4164.     int i,k,hue,brite,j;
  4165.     int r,g,b;
  4166.     float color[3];
  4167.     double dbrite,dval;
  4168.     float val,minval,sat,inten;
  4169.     float fval,fk;
  4170.     FILE *fplut;
  4171.     int end=0,scale,sum;
  4172.     char string[100];
  4173.     long del,mindel,l1,l2,l3,l4;
  4174.  
  4175.     scale=1;
  4176.     if(Num_Color==16)
  4177.         scale=17;
  4178.     for(k=0;k<Num_Color;k++)
  4179.     {
  4180.         Hdr[Img].lut[k].r=k*scale;
  4181.         Hdr[Img].lut[k].g=k*scale;
  4182.         Hdr[Img].lut[k].b=k*scale;
  4183.     }
  4184.     ActiveLut='G';
  4185.     if(type=='P')
  4186.     {
  4187.         fplut=open_to_read_text(filename);
  4188.         if(fplut)
  4189.         {
  4190.             i=0;
  4191.             do
  4192.             {
  4193.                 i+=1;
  4194.                 fscanf(fplut,"%s",string);
  4195.             }while(strcmpi(string,"end")!=0&&i<50);
  4196.             if(strcmpi(string,"end")!=0)
  4197.                 rewind(fplut);
  4198.             for(i=0;i<256;i++)
  4199.             {
  4200.                 fscanf(fplut,"%d%d%d%d",&k,&r,&g,&b);
  4201.                 Hdr[Img].lut[i].r=r;
  4202.                 Hdr[Img].lut[i].g=g;
  4203.                 Hdr[Img].lut[i].b=b;
  4204.             }
  4205.             fclose(fplut);
  4206.         }
  4207.         else
  4208.             return(-1);
  4209.         if(VideoType=='V'||VideoType=='E')
  4210.         {
  4211.             for(i=0;i<256;i++)
  4212.             {
  4213.                 sum=(int)Hdr[Img].lut[i].r*10;
  4214.                 sum+=(int)Hdr[Img].lut[i].g*8;
  4215.                 sum+=(int)Hdr[Img].lut[i].b*2;
  4216.                 sum/=319;
  4217.                 Hdr[Img].vga_color[i]=sum;
  4218.             }
  4219.             for(k=0;k<Num_Color;k++)
  4220.             {
  4221.                 Hdr[Img].lut[k].r=k*scale;
  4222.                 Hdr[Img].lut[k].g=k*scale;
  4223.                 Hdr[Img].lut[k].b=k*scale;
  4224.             }
  4225.         }
  4226.         ActiveLut='P';
  4227.     }
  4228.     if(type=='g')
  4229.     {
  4230.         for(k=0;k<Num_Color;k++)
  4231.         {
  4232.             Hdr[Img].lutc[k].r=Hdr[Img].lut[k].r=k*scale;
  4233.             Hdr[Img].lutc[k].g=Hdr[Img].lut[k].g=k*scale;
  4234.             Hdr[Img].lutc[k].b=Hdr[Img].lut[k].b=k*scale;
  4235.         }
  4236.         ActiveLut='g';
  4237.     }
  4238.     if(type=='G')
  4239.     {
  4240.         for(k=0;k<Num_Color;k++)
  4241.         {
  4242.             Hdr[Img].lut[k].r=k*scale;
  4243.             Hdr[Img].lut[k].g=k*scale;
  4244.             Hdr[Img].lut[k].b=k*scale;
  4245.         }
  4246.         ActiveLut='G';
  4247.     }
  4248.     if(type=='i')
  4249.     {
  4250.         for(k=0;k<Num_Color;k++)
  4251.         {
  4252.             Hdr[Img].lutc[k].r=Hdr[Img].lut[k].r=k*scale;
  4253.             Hdr[Img].lutc[k].g=Hdr[Img].lut[k].g=k*scale;
  4254.             Hdr[Img].lutc[k].b=Hdr[Img].lut[k].b=k*scale;
  4255.         }
  4256.         Hdr[Img].lut[ 64].r=  0;Hdr[Img].lut[ 64].g=  0;Hdr[Img].lut[ 64].b=128;
  4257.         Hdr[Img].lut[127].r=  0;Hdr[Img].lut[127].g=100;Hdr[Img].lut[127].b=  0;
  4258.         Hdr[Img].lut[191].r=255;Hdr[Img].lut[191].g=  0;Hdr[Img].lut[191].b=  0;
  4259.         Hdr[Img].lut[192].r=255;Hdr[Img].lut[192].g=128;Hdr[Img].lut[192].b=  0;
  4260.         Hdr[Img].lut[193].r=255;Hdr[Img].lut[193].g=255;Hdr[Img].lut[193].b=  0;
  4261.         Hdr[Img].lut[194].r=  0;Hdr[Img].lut[194].g=255;Hdr[Img].lut[194].b=  0;
  4262.         Hdr[Img].lut[195].r=  0;Hdr[Img].lut[195].g=255;Hdr[Img].lut[195].b=255;
  4263.         Hdr[Img].lut[196].r= 20;Hdr[Img].lut[196].g= 55;Hdr[Img].lut[196].b=255;
  4264.         Hdr[Img].lut[253].r=100;Hdr[Img].lut[253].g=  1;Hdr[Img].lut[253].b=  1;
  4265.         Hdr[Img].lut[254].r=100;Hdr[Img].lut[254].g=  1;Hdr[Img].lut[254].b=  1;
  4266.         ActiveLut='i';
  4267.     }
  4268.     if(type=='r')
  4269.     {
  4270.         for(k=0;k<Num_Color;k++)
  4271.         {
  4272.             Hdr[Img].lut[k].r=Hdr[Img].lutc[k].r;
  4273.             Hdr[Img].lut[k].g=Hdr[Img].lutc[k].g;
  4274.             Hdr[Img].lut[k].b=Hdr[Img].lutc[k].b;
  4275.         }
  4276.         ActiveLut='r';
  4277.     }
  4278.     mindel=16777216;
  4279.     for(i=0;i<Num_Color;i++)
  4280.     {
  4281.         l1=Blk.r;
  4282.         l2=Hdr[Img].lut[i].r;
  4283.         l3=Hdr[Img].lut[i].g;
  4284.         l4=Hdr[Img].lut[i].b;
  4285.         del=(l1-l2)*(l1-l2)+(l1-l3)*(l1-l3)+(l1-l4)*(l1-l4);
  4286.         if(del<mindel)
  4287.         {
  4288.             mindel=del;
  4289.             Black=i;
  4290.         }
  4291.     }
  4292.     mindel=16777216;
  4293.     for(i=0;i<Num_Color;i++)
  4294.     {
  4295.         l1=D_G.r;
  4296.         l2=Hdr[Img].lut[i].r;
  4297.         l3=Hdr[Img].lut[i].g;
  4298.         l4=Hdr[Img].lut[i].b;
  4299.         del=(l1-l2)*(l1-l2)+(l1-l3)*(l1-l3)+(l1-l4)*(l1-l4);
  4300.         if(del<mindel)
  4301.         {
  4302.             mindel=del;
  4303.             D_Grey=i;
  4304.         }
  4305.     }
  4306.     mindel=16777216;
  4307.     for(i=0;i<Num_Color;i++)
  4308.     {
  4309.         l1=M_G.r;
  4310.         l2=Hdr[Img].lut[i].r;
  4311.         l3=Hdr[Img].lut[i].g;
  4312.         l4=Hdr[Img].lut[i].b;
  4313.         del=(l1-l2)*(l1-l2)+(l1-l3)*(l1-l3)+(l1-l4)*(l1-l4);
  4314.         if(del<mindel)
  4315.         {
  4316.             mindel=del;
  4317.             M_Grey=i;
  4318.         }
  4319.     }
  4320.     mindel=16777216;
  4321.     for(i=0;i<Num_Color;i++)
  4322.     {
  4323.         l1=L_G.r;
  4324.         l2=Hdr[Img].lut[i].r;
  4325.         l3=Hdr[Img].lut[i].g;
  4326.         l4=Hdr[Img].lut[i].b;
  4327.         del=(l1-l2)*(l1-l2)+(l1-l3)*(l1-l3)+(l1-l4)*(l1-l4);
  4328.         if(del<mindel)
  4329.         {
  4330.             mindel=del;
  4331.             L_Grey=i;
  4332.         }
  4333.     }
  4334.     mindel=16777216;
  4335.     for(i=0;i<Num_Color;i++)
  4336.     {
  4337.         l1=Wht.r;
  4338.         l2=Hdr[Img].lut[i].r;
  4339.         l3=Hdr[Img].lut[i].g;
  4340.         l4=Hdr[Img].lut[i].b;
  4341.         del=(l1-l2)*(l1-l2)+(l1-l3)*(l1-l3)+(l1-l4)*(l1-l4);
  4342.         if(del<mindel)
  4343.         {
  4344.             mindel=del;
  4345.             White=i;
  4346.         }
  4347.     }
  4348.     WritePalette(Hdr[Img].lut);
  4349.     return(1);
  4350. }
  4351.  
  4352. /********************************************************************
  4353. **
  4354. **     options:
  4355. **
  4356. **       -1 -- remove menu but get no answer
  4357. **        0 -- return answer and set menu colors to GREYs
  4358. **        1 -- return answer but leave colors alone
  4359. **
  4360. ********************************************************************* */
  4361.  
  4362. int do_menu_buff(menu,num,xc,yc,start,back,words,boxs,font)
  4363.  
  4364. char *menu[];
  4365. int num,xc,yc,start,back,words,boxs;
  4366. int font[128][25];
  4367.  
  4368. {
  4369.     int i,j,k;
  4370.     char ans,ans2;
  4371.     int len=0,l,size=FontSize,val,valo;
  4372.     int black=Black,dGREY=back,lGREY=words,white=boxs;
  4373.     int wide;
  4374.  
  4375.     for(k=0;k<num;k++)
  4376.         if((l=strlen(menu[k]))>len)len=l;
  4377.     if(len==0)return(-1);
  4378.     wide=(len+1)*15/size+1;
  4379.     if((ScreenXs-1-wide)<xc)xc=ScreenXs-1-wide;
  4380.  
  4381.     if((xc+(len+1)*15/size+1)<ScreenXs)
  4382.     {
  4383.         save_sub_mem(xc,yc,(len+1)*15/size+1,30/size*num+1);
  4384.         paint_box(0,dGREY,Buffer,xc,yc,(len+1)*15/size+1,30/size*num+1);
  4385.         
  4386.         for(k=0;k<num;k++)
  4387.         {    
  4388.             box(0,xc,yc+k*(30/size),dGREY,(len+1)*15/size,30/size);
  4389.             plot_font_h(lGREY,xc+15/size,yc+k*30/size+5/size,menu[k],size,font);
  4390.         }
  4391.         box(0,xc,yc,M_Grey,(len+1)*15/size,30/size*num);
  4392.         val=valo=start;
  4393.         box(0,xc,yc+val*(30/size),white,(len+1)*15/size,30/size);
  4394.         do
  4395.         {
  4396.             if((ans=getch())==0)
  4397.             {
  4398.                 ans2=getch();
  4399.                 if(ans2==50)
  4400.                 {
  4401.                     recall_sub_mem(xc,yc,(len+1)*15/size+1,30/size*num+1);
  4402.  
  4403.                     getch();
  4404.                     paint_box(0,dGREY,Buffer,
  4405.                         xc,yc,(len+1)*15/size+1,30/size*num+1);
  4406.                     for(k=0;k<num;k++)
  4407.                     {    
  4408.                         plot_font_h(lGREY,xc+15/size,
  4409.                                     yc+k*30/size+5/size,menu[k],size,font);
  4410.                     }
  4411.                 }
  4412.                 if(ans2=='H')
  4413.                 {
  4414.                     if(val>0)val-=1;
  4415.                     else val=num-1;
  4416.                 }
  4417.                 if(ans2=='P')
  4418.                 {
  4419.                     if(val<num-1)val+=1;
  4420.                     else val=0;
  4421.                 }
  4422.             }
  4423.  
  4424.             for(i=0;i<num;i++)
  4425.                 if(ans==menu[i][0])
  4426.                 {
  4427.                     val=i;
  4428.                     ans=13;
  4429.                 }
  4430.             if(ans==27)
  4431.             {
  4432.                 val=num-1;
  4433.                 ans=13;
  4434.             }
  4435.  
  4436.             box(0,xc,yc+valo*(30/size),dGREY,(len+1)*15/size,30/size);
  4437.             valo=val;
  4438.             box(0,xc,yc,M_Grey,(len+1)*15/size,30/size*num);
  4439.             box(0,xc,yc+val*(30/size),white,(len+1)*15/size,30/size);
  4440.         }while(ans!=13);
  4441.     }
  4442.     box(0,xc,yc,dGREY,(len+1)*15/size,30/size*num);
  4443.     box(0,xc,yc+val*(30/size),M_Grey,(len+1)*15/size,30/size);
  4444.  
  4445.     recall_sub_mem(xc,yc,(len+1)*15/size+1,30/size*num+1);
  4446.     return(val);
  4447. }
  4448.  
  4449. /********************************************************************
  4450. **
  4451. **
  4452. **
  4453. ********************************************************************* */
  4454.  
  4455. int save_sub_mem(xc,yc,xs,ys)
  4456.  
  4457. int xc,yc,xs,ys;
  4458.  
  4459. {
  4460.     int i,j,k;
  4461.  
  4462.     for(i=0;i<ys;i++)
  4463.         getrow(3,xc,xc+xs-1,i+yc,Mbuff+xs*i);
  4464. }
  4465.  
  4466. /********************************************************************
  4467. **
  4468. **
  4469. **
  4470. ********************************************************************* */
  4471.  
  4472. int recall_sub_mem(xc,yc,xs,ys)
  4473.  
  4474. int xc,yc,xs,ys;
  4475.  
  4476. {
  4477.     int i,j,k;
  4478.  
  4479.     for(i=0;i<ys;i++)
  4480.         plotrow(3,xc,xc+xs-1,i+yc,Mbuff+xs*i);
  4481. }
  4482.  
  4483. /**************************************************************************
  4484. **
  4485. **
  4486. **
  4487. ************************************************************************* */
  4488.  
  4489. char fsplit(instring,path,name,type)
  4490.  
  4491. char *instring,*path,*name,*type;
  4492.  
  4493. {
  4494.     int i,j,k;
  4495.     int dot=-1,last_slash=-1,len=strlen(instring),first_slash=-1;
  4496.     int num=0,colon=-1;
  4497.     int disk=0;
  4498.     char string[STR_LEN];
  4499.  
  4500.     strcpy(string,instring);
  4501.     path[0]='\0';
  4502.     name[0]='\0';
  4503.     type[0]='\0';
  4504.  
  4505.     for(i=0;i<len;i++)
  4506.     {
  4507.         if(string[i]==':')
  4508.             colon=i;
  4509.         else if(string[i]=='\\')
  4510.         {
  4511.             last_slash=i;
  4512.             if(first_slash<0)
  4513.                 first_slash=i;
  4514.         }    
  4515.         else if(string[i]=='.')
  4516.             dot=i;
  4517.     }
  4518.     if(dot<0&&first_slash>=0&&last_slash<len-1)  /* d:test */
  4519.     {
  4520.         string[len]='\\';
  4521.         last_slash=len;
  4522.         len+=1;
  4523.         string[len]='\0';
  4524.     }
  4525.     if(dot<0&&first_slash<0&&len>colon-1)
  4526.     {
  4527.         string[len]='.';
  4528.         dot=len;
  4529.         len+=1;
  4530.         string[len]='\0';
  4531.     }
  4532.     if(colon>0)
  4533.         disk=string[0];
  4534.     if(first_slash>=0)
  4535.     {
  4536.         for(i=first_slash;i<=last_slash;i++)
  4537.             path[i-first_slash]=string[i];
  4538.         path[last_slash-first_slash+1]='\0';
  4539.     }
  4540.     if(last_slash>0&&last_slash<len-1&&dot>0)
  4541.     {
  4542.         for(i=last_slash+1;i<dot;i++)
  4543.             name[i-last_slash-1]=string[i];
  4544.         name[dot-last_slash-1]='\0';
  4545.     }
  4546.     if(colon>0&&last_slash<0&&dot>0)    /* d:test.img */
  4547.     {
  4548.         for(i=colon+1;i<dot;i++)
  4549.             name[i-colon-1]=string[i];
  4550.         name[dot-colon]='\0';
  4551.     }
  4552.     if(colon<0&&last_slash<0&&dot>0)    /* test.img */
  4553.     {
  4554.         for(i=0;i<dot;i++)
  4555.             name[i]=string[i];
  4556.         name[dot]='\0';
  4557.     }
  4558.     if(dot>0&&dot<len-1)
  4559.     {
  4560.         for(i=dot+1;i<len;i++)
  4561.             type[i-dot-1]=string[i];
  4562.         type[len-dot-1]='\0';
  4563.         if(strlen(type)>3)
  4564.             type[3]='\0';
  4565.     }
  4566.     return(disk);
  4567. }
  4568.  
  4569.  
  4570. /***********************************************************************
  4571. **
  4572. **
  4573. **
  4574. **
  4575. ************************************************************************/
  4576.  
  4577. FILE *open_to_write_text(name)
  4578.  
  4579. char *name;
  4580.  
  4581. {
  4582.     int i,j,k;
  4583.     FILE *fp;
  4584.     char string[STR_LEN];
  4585.  
  4586.     for(j=0;j<NumPath;j++)
  4587.     {
  4588.         sprintf(string,"%s%s",Path[j],name);
  4589.         fp=fopen(string,"wt");
  4590.         if(fp)
  4591.         {
  4592.             strcpy(LastFile,name);
  4593.             return(fp);
  4594.         }
  4595.     }
  4596.     clearerr(fp);
  4597.     fp=NULL;
  4598.     return(fp);
  4599. }
  4600.  
  4601. /***********************************************************************
  4602. **
  4603. **
  4604. **
  4605. **
  4606. ************************************************************************/
  4607.  
  4608. FILE *open_to_read_text(name)
  4609.  
  4610. char *name;
  4611.  
  4612. {
  4613.     int i,j,k;
  4614.     FILE *fp;
  4615.     char string[STR_LEN];
  4616.  
  4617.     for(j=0;j<NumPath;j++)
  4618.     {
  4619.         sprintf(string,"%s%s",Path[j],name);
  4620.         fp=fopen(string,"rt");
  4621.         if(fp)
  4622.         {
  4623.             strcpy(LastFile,name);
  4624.             return(fp);
  4625.         }
  4626.     }
  4627.     clearerr(fp);
  4628.     fp=NULL;
  4629.     return(fp);
  4630. }
  4631.  
  4632. /***********************************************************************
  4633. **
  4634. **
  4635. **
  4636. **
  4637. ************************************************************************/
  4638.  
  4639. FILE *open_to_write_binary(name)
  4640.  
  4641. char *name;
  4642.  
  4643. {
  4644.     int i,j,k;
  4645.     FILE *fp;
  4646.     char string[STR_LEN];
  4647.  
  4648.     for(j=0;j<NumPath;j++)
  4649.     {
  4650.         sprintf(string,"%s%s",Path[j],name);
  4651.         fp=fopen(string,"wb");
  4652.         if(fp)
  4653.         {
  4654.             strcpy(LastFile,name);
  4655.             return(fp);
  4656.         }
  4657.     }
  4658.     clearerr(fp);
  4659.     fp=NULL;
  4660.     return(fp);
  4661. }
  4662.  
  4663.  
  4664. /***********************************************************************
  4665. **
  4666. **
  4667. **
  4668. **
  4669. ************************************************************************/
  4670.  
  4671. FILE *open_to_read_binary(name)
  4672.  
  4673. char *name;
  4674.  
  4675. {
  4676.     int i,j,k;
  4677.     FILE *fp;
  4678.     char string[STR_LEN];
  4679.     int len;
  4680.  
  4681.     string[0]='\0';
  4682.     for(j=0;j<NumPath;j++)
  4683.     {
  4684.         len=strlen(Path[j])+strlen(name);
  4685.         if(len>0&&len<STR_LEN);
  4686.         {
  4687.             sprintf(string,"%s%s",Path[j],name);
  4688.             fp=fopen(string,"rb");
  4689.             if(fp)
  4690.             {
  4691.                 strcpy(LastFile,name);
  4692.                 return(fp);
  4693.             }    
  4694.         }
  4695.     }
  4696.     clearerr(fp);
  4697.     fp=NULL;
  4698.     return(fp);
  4699. }
  4700.  
  4701.